Visualizzazione post con etichetta script. Mostra tutti i post
Visualizzazione post con etichetta script. Mostra tutti i post

giovedì 24 luglio 2025

MS Outlook: Eliminare le cartelle vuote tramite PowerShell

Le cartelle vuote in Outlook possono accumularsi nel tempo, rendendo più difficile la gestione della posta e occupando spazio inutilmente. Questo articolo illustra come utilizzare uno script PowerShell per identificare ed eliminare in modo efficiente le cartelle di posta vuote, inclusi i feed RSS, mantenendo al sicuro le cartelle predefinite di sistema.

Per scaricare lo script è possibile cliccare sul seguente link


Lo script PowerShell esegue:
  • Analisi Gerarchica
    Scansiona ricorsivamente l'intera struttura delle cartelle di una casella di posta o di un file di dati Outlook.
  • Identificazione delle Cartelle di Posta
    Si concentra solo sulle cartelle che contengono (o potrebbero contenere) messaggi di posta elettronica, ignorando elementi come calendari o contatti.
  • Rilevamento Cartelle Nascoste
    Identifica e ignora le cartelle di sistema nascoste, evitando operazioni indesiderate su componenti interni di Outlook.
  • Report Dettagliato
    Genera un file di testo con l'elenco completo delle cartelle visibili, mostrando il loro percorso completo e il numero di elementi contenuti.
  • Pulizia Intelligente
    Offre la funzionalità (opzionale e controllata) di eliminare automaticamente le cartelle che sono completamente vuote e non contengono sottocartelle.

Come Funziona lo Script

Lo script si basa sull'interazione con il modello a oggetti COM (Component Object Model) di Microsoft Outlook, una potente interfaccia che permette a script e applicazioni esterne di controllare Outlook.

1. Inizializzazione e Connessione a Outlook
try {
    $outlookApp = New-Object -ComObject Outlook.Application
}
catch {
    Write-Error "Errore durante l'avvio dell'applicazione Outlook. Assicurati che Outlook sia installato."
    exit 1 
}
$mapiNamespace = $outlookApp.GetNameSpace("MAPI")

Il primo passo è creare un'istanza dell'applicazione Outlook. Un blocco try-catch garantisce che lo script gestisca elegantemente l'assenza di Outlook o altri problemi di avvio. Successivamente, si ottiene il Namespace("MAPI"), che è la porta d'accesso a tutti gli archivi di dati di Outlook (caselle di posta, file PST/OST, archivi).


2. Selezione dell'Archivio Dati
try {
    Write-Host "Seleziona la cartella da cui desideri iniziare l'analisi (questa sarà la radice della scansione)..."
    $startFolder = $mapiNamespace.PickFolder() # Cattura l'oggetto Folder selezionato
    
    if ($startFolder -eq $null) {
        Write-Error "Nessuna cartella selezionata. Lo script verrà terminato."
                [System.Runtime.InteropServices.Marshal]::ReleaseComObject($mapiNamespace) | Out-Null
        [System.Runtime.InteropServices.Marshal]::ReleaseComObject($outlookApp) | Out-Null
        exit 1
    }
    Write-Host "La scansione inizierà dalla cartella: $($startFolder.FullFolderPath)"
}
catch {
    Write-Error "Errore durante la selezione della cartella. Lo script verrà terminato."
    # Rilascia l'oggetto Outlook prima di uscire per pulire le risorse.
    [System.Runtime.InteropServices.Marshal]::ReleaseComObject($mapiNamespace) | Out-Null
    [System.Runtime.InteropServices.Marshal]::ReleaseComObject($outlookApp) | Out-Null
    exit 1
}

Una caratteristica chiave è la flessibilità: lo script chiede all'utente di selezionare una cartella tramite l'interfaccia di Outlook ($mapiNamespace.PickFolder()). Questo permette di scegliere qualsiasi casella di posta configurata o file di dati (come un PST), rendendo lo script versatile per diversi scenari. Una volta selezionata la cartella questa viene impostata come punto di partenza per la scansione.
Selezione cartella
FIG 1 - Selezione cartella



3. Preparazione dell'Output
$timestamp = Get-Date -Format "yyyy-MM-dd.HH-mm-ss"
$outputDirectory = Join-Path -Path $env:USERPROFILE -ChildPath "Documents"
$outputFileName = "OutlookFolderNames_$timestamp.txt"
$outputPath = Join-Path -Path $outputDirectory -ChildPath $outputFileName

if (-not (Test-Path -Path $outputDirectory -PathType Container)) {
    New-Item -Path $outputDirectory -ItemType Directory | Out-Null
    Write-Host "Creata la directory: $outputDirectory"
}

Per un'analisi tracciabile, lo script genera un file di testo con un timestamp unico nel nome, salvandolo nella cartella "Documenti" dell'utente. Viene anche inclusa una verifica per creare la cartella "Documenti" se non esistente, garantendo che l'operazione di scrittura del file avvenga senza errori.


4. La Funzione Ricorsiva ListAndManageFolders
Il cuore dello script è una funzione ricorsiva che attraversa l'intera gerarchia delle cartelle:

Function ListAndManageFolders {
    param(
        [Parameter(Mandatory=$true)]
        [object]$Folders, # Collezione di oggetti Outlook.Folder
        [string]$Indent = "" # Stringa per l'indentazione gerarchica
    )

    foreach ($folder in $Folders) {
        $propertyAccessor = $null

        try {
            if ($folder -eq $null) {
                Write-Warning "Trovato un oggetto cartella nullo, saltato."
                continue
            }
            if ($folder.DefaultMessageClass -eq "IPM.Note") {
                if ($folder.Folders.Count -gt 0) {
                    ListAndManageFolders -Folders $folder.Folders -Indent ($Indent + "  ")
                }
                $propertyAccessor = $folder.PropertyAccessor
                $isHidden = $false
                try {
                    $isHidden = $propertyAccessor.GetProperty($hiddenFolderPropName)
                }
                catch {
                    Write-Verbose "Impossibile leggere la proprietà nascosta per la cartella $($folder.FullFolderPath). Assunta non nascosta."
                    $isHidden = $false
                }
                if ($isHidden -ne $true) {
                    $outputLine = "$Indent$($folder.FullFolderPath) ($($folder.Items.Count) elementi)"
                    $outputLine | Out-File -FilePath $outputPath -Append -Encoding UTF8
                    Write-Host $outputLine
                    if ($folder.Items.Count -eq 0 -and $folder.Folders.Count -eq 0) {
                        Write-Host "$Indent   [ELIMINAZIONE] Cartella vuota rilevata: $($folder.Name)" -ForegroundColor Yellow
                        try {
                            $folder.Delete()
                            Write-Host "$Indent   [SUCCESSO] Cartella eliminata: $($folder.Name)" -ForegroundColor Green
                        }
                        catch {
                            Write-Error "$Indent   [ERRORE] Impossibile eliminare la cartella $($folder.Name): $($_.Exception.Message)"
                        }
                    }
                }
            }
        }
        catch {
            Write-Error "Errore durante l'elaborazione della cartella '$($folder.FullFolderPath)': $($_.Exception.Message)"
        }
        finally {
            if ($propertyAccessor -ne $null) {
                [System.Runtime.InteropServices.Marshal]::ReleaseComObject($propertyAccessor) | Out-Null
            }
        }
    }
}

- Filtro per Tipo di Cartella: if ($folder.DefaultMessageClass -eq "IPM.Note") assicura che vengano elaborate solo le cartelle destinate ai messaggi di posta (incluse le cartelle RSS), escludendo calendari, contatti, ecc.

- Rilevamento Cartelle Nascoste: Viene utilizzata la proprietà MAPI http://schemas.microsoft.com/mapi/proptag/0x10F4000B (corrispondente a PR_ATTR_HIDDEN) per identificare le cartelle nascoste di sistema. Queste vengono ignorate per evitare modifiche indesiderate.

- Output e Visualizzazione: Per ogni cartella visibile, il suo percorso completo e il conteggio degli elementi vengono scritti sia nel file di output che nella console, con un'indentazione che riflette la gerarchia.

- Logica di Eliminazione:
if ($folder.Items.Count -eq 0 -and $folder.Folders.Count -eq 0) {
    Write-Host "$Indent   [ELIMINAZIONE] Cartella vuota rilevata: $($folder.Name)" -ForegroundColor Yellow
    try {
          $folder.Delete()
          Write-Host "$Indent   [SUCCESSO] Cartella eliminata: $($folder.Name)" -ForegroundColor Green
    }
    catch {
           Write-Error "$Indent   [ERRORE] Impossibile eliminare la cartella $($folder.Name): $($_.Exception.Message)"
    }
}

Questa sezione è cruciale e potenzialmente distruttiva. La cartella viene eliminata solo se è completamente vuota (zero elementi e zero sottocartelle). Viene fornito un feedback visivo e una robusta gestione degli errori per ogni tentativo di eliminazione.

Output
FIG 2 - Output



5. Gestione degli Oggetti COM e Pulizia
[System.Runtime.InteropServices.Marshal]::ReleaseComObject($startFolder) | Out-Null # Rilascia la cartella di partenza
[System.Runtime.InteropServices.Marshal]::ReleaseComObject($mapiNamespace) | Out-Null
[System.Runtime.InteropServices.Marshal]::ReleaseComObject($outlookApp) | Out-Null

Un aspetto critico della programmazione con oggetti COM è la gestione della memoria. A differenza degli oggetti .NET, gli oggetti COM non vengono automaticamente rilasciati dal garbage collector di PowerShell. Non rilasciare questi oggetti può portare a perdite di memoria, blocchi di Outlook o processi "fantasma" in background. Lo script include chiamate esplicite a [System.Runtime.InteropServices.Marshal]::ReleaseComObject() per ogni oggetto COM creato, garantendo una pulizia efficiente delle risorse.


Considerazioni Importanti:

Backup: Prima di eseguire qualsiasi script che comporti l'eliminazione di dati, è fondamentale eseguire un backup completo della casella di posta o del file PST.

Autorizzazioni: Lo script deve essere eseguito con un utente che abbia le autorizzazioni necessarie per interagire con Outlook e per eliminare le cartelle.

Parametro -WhatIf: Per future evoluzioni, si potrebbe considerare di aggiungere un parametro -WhatIf alla funzione di eliminazione, permettendo agli amministratori di simulare l'eliminazione senza effettivamente apportare modifiche.





venerdì 1 dicembre 2023

PowerShell: Muovere il puntatore del mouse

Tramite PowerShell è possibile muovere il puntatore del mouse utilizzando l'assembly System.Windows.Forms, che contiene le classi per gestire la finestra grafica.

PowerShell


Un semplice script che muove il mouse ogni 30 secondi è il seguente

 Add-Type -AssemblyName System.Windows.Forms  
 # Ciclo infinito che aggiorna la posizione del mouse ogni 30 secondi finchè non viene premuto CTRL+C o chiusa la finestra  
 while ($true)  
 {  
  # Rileva la posizione attuale del mouse  
  $Pos = [System.Windows.Forms.Cursor]::Position  
  # Creo le nuove coordinate del puntatore aggiungendo un pixel e facendo in modo da non uscire dallo schermo (% 500)  
  $x = ($pos.X % 500) + 1  
  $y = ($pos.Y % 500) + 1  
  # Posiziona il puntatore del mouse nelle nuove coordinate  
  [System.Windows.Forms.Cursor]::Position = New-Object System.Drawing.Point($x, $y)  
  # Attende 30 secondi  
  Start-Sleep -Seconds 30  
 }  
Nello script, per evitare che il mouse finisca fuori dallo schermo, è stato adottato un piccolo espediente: il valore delle coordinate viene diviso per 500 e viene prelevato il resto della divisione (che sarà sicuramente inferiore a 500).

Per muovere il cursore in maniera randomica sullo schermo si può utilizzare il seguente script
 Add-Type -AssemblyName System.Windows.Forms  
   
 # Rileva la risoluzione del monitor principale  
 $WindowSize = [System.Windows.Forms.Screen]::GetWorkingArea(0)  
 $MaxWidth = $WindowSize.Width  
 $MaxHeight = $WindowSize.Height  
   
 #Esegue un loop e aggiorna la posizione del mouse finché non viene premuto CTRL + C o viene chiusa la finestra  
 while ($true)  
 {  
   # Genera randomincamente le nuove coordinale tenendo conto della risoluzione  
   $x = (Get-Random -Minimum 0 -Maximum $MaxWidth)  
   $y = (Get-Random -Minimum 0 -Maximum $MaxHeight)  
   Write-Host "`rNew position: x:$($x),y:$($y)  " -NoNewLine  
   # Posiziona il cursore nelle nuove coordinate  
   [System.Windows.Forms.Cursor]::Position = New-Object System.Drawing.Point($x, $y)  
   # Attende 30 secondi  
   Start-Sleep -Seconds 30  
 }  
Per chi stesse pensando di utilizzare questo metodo per evitare che Windows vada in stand-by in caso di inattività, dovrà pensare ad una soluzione alternativa. Il movimento del mouse tramite PowerShell, infatti, non è sufficiente affinché il sistema venga considerato "attivo" e Windows provvederà comunque a visualizzare lo screensaver, oscurare/bloccare lo schermo o attivare il risparmio energetico dopo un periodo di inattività.
Per fare in modo che Windows rilevi che il pc sia utilizzato è necessario un input da parte dell'utente e non solo il movimento del mouse. Per simulare l'input da parte dell'utente, ad esempio la pressione di un tasto, si può utilizzare il metodo SendKeys che illustrerò in un altro articolo.




mercoledì 13 luglio 2022

PowerShell: Verificare se un account utente è disabilitato/abilitato in Active Directory

Per verificare se un account utente è abilitato o disabilitato in Active Directory è possibile utilizzare il seguente script PowerShell
 $User = Read-Host -Prompt "Inserisci il nome dell'account";    
 Get-ADUser -Filter {name -like $User -or samaccountname -like $User} | Select Name, SamAccountName, Enabled   
Verifica account
FIG 1 - Verifica account


Se si dispone di un file contenente l'elenco degli utenti da verificare è possibile utilizzare il seguente codice andando a sostituire la stringa C:\Temp\ElencoUtenti.txt con il percorso e il nome del file contenente l'elenco.
 $userList = "C:\Temp\ElencoUtenti.txt"  
 $users = Get-Content $userList  
 foreach ($user in $users){  
  Get-ADUser -Filter {name -like $user -or samaccountname -like $user} | Select Name, SamAccountName, Enabled   
 }  





giovedì 3 febbraio 2022

PowerShell: Ottimizzare le prestazioni degli script

A chi lavora con gli script PowerShell viene spesso richiesto di ottimizzare il codice e i tempi di esecuzione al fine di ridurre gli impatti sul sistema. Per script complessi e lunghi non è semplice individuare la causa di ritardi nell'esecuzione e cosa andare ad ottimizzare. In questi casi può essere d'aiuto un modulo PowerShell chiamato "PSProfiler" che visualizza il tempo di esecuzione di ogni linea presente all'interno dello script.

Per poter utilizzare tale modulo va prima installato con il comando
Install-Module -Name PSProfiler -Scope CurrentUser  
PSProfiler
FIG 1 - PSProfiler

Successivamente lo script da analizzare va invocato mediante Measure-Script
Measure-Script -Path  C:\Users\Virtual\bubble_sort.ps1

Una volta completata l'esecuzione dello script, viene visualizzato un rapporto dettagliato che mostra quante volte ogni linea di codice è stata eseguita e quanto tempo ha impiegato.
Report PSProfiler
FIG 2 - Report PSProfiler






martedì 18 gennaio 2022

PowerShell: Catturare uno screenshot

Tramite PowerShell è possibile catturare lo schermo e salvare lo screenshot all'interno di un file utilizzando i tipi presenti in System.Windows.Forms. Il seguente script mostra come catturare lo schermo virtuale e salvarlo all'interno di un file bitmap per poi aprirlo con il programma associato.
  #specifica il path in cui salvare lo screenshot   
  $Path = "$Env:temp\screenshot.bmp"   
     
  Add-Type -AssemblyName System.Windows.Forms   
     
  #Prepara l'area da catturare   
  $screen = [System.Windows.Forms.SystemInformation]::VirtualScreen   
  $width = $screen.Width   
  $height = $screen.Height   
  $left = $screen.Left   
  $top = $screen.Top   
  #Crea un immagine bitmap   
  $bitmap = [System.Drawing.Bitmap]::new($width, $height)   
  #Crea un nuovo oggetto Graphics dall'oggetto $bitmap   
  $MyDrawing = [System.Drawing.Graphics]::FromImage($bitmap)   
  #Copia il contenuto dello schermo nell'oggetto $bitmap   
  $MyDrawing.CopyFromScreen($left, $top, 0, 0, $bitmap.Size)   
     
  #Salva lo screenshot nel percorso specificato   
  $bitmap.Save($Path)   
  #visualizza l'immagine bmp salvata utilizzando il programma associato   
  Start-Process -FilePath $Path   


Screenshot
FIG 1 - Screenshot

Dal seguente link è possibile scaricare il codice dello script:





mercoledì 24 marzo 2021

PowerShell: Convertire un file eseguibile in un file di testo (Parte 1)

In alcuni contesti, per passare "inosservati" e superare restrizioni e controlli, può essere utile trasformare temporaneamente un file eseguibile in un innocuo file di testo per poi eseguire l'operazione inversa in un secondo momento. Tale conversione può essere eseguita tramite un semplice script PowerShell

La conversione può essere effettuata con poche righe di codice come quelle mostrate di seguito

    [CmdletBinding()] Param(
        [Parameter(Position = 0, Mandatory = $True)]
        [String]
        $FileEXE, 
        
        [Parameter(Position = 1, Mandatory = $False)]
        [String]
        $FileTXT = "$pwd\EseguibileConvertito.txt"
    )
    [byte[]] $dump = Get-Content -encoding byte -path "$FileEXE" -ReadCount 0
    [System.IO.File]::WriteAllLines($FileTXT, ([string]$dump))
    Write-Output "Il file e' stato convertito in $FileTXT"


Innanzitutto andiamo a caricare i parametri passati durante la chiamata dello script. Nella variabile $FileEXE andiamo a caricare il primo parametro passato, obbligatorio, che corrisponde al file eseguibile da convertire.
Il secondo parametro, facoltativo, verrà caricato nella variabile $FileTXT e rappresenta il nome del file di testo in cui verrà salvata la conversione. Nel caso in cui tale parametro non venisse specificato, il file di testo verrà creato nel percorso corrente ($pwd) e gli verrà assegnato il nome EseguibileConvertito.txt.

Le due istruzioni più interessanti sono
    [byte[]] $dump = Get-Content -encoding byte -path "$FileEXE" -ReadCount 0
    [System.IO.File]::WriteAllLines($FileTXT, ([string]$dump))

Con la prima, attraverso il cmdlet Get-Content e il parametro -encoding byte, andiamo a caricare tutti i byte che compongono il file eseguibile in un array di byte. Il parametro -ReadCount 0 permette di leggere tutto il contenuto del file eseguibile in una singola operazione.
Nell'istruzione successiva i byte vengono trasformati in testo per essere scritti all'interno del file di output. Il file di output avrà una dimensione superiore a quella del file eseguibile di partenza. 

Dal seguente link è possibile scaricare lo script Exe2Txt.ps1

Script PowerShell Exe2Txt
FIG 1 - Script PowerShell Exe2Txt.ps1




martedì 3 novembre 2020

PowerShell: Individuare e cancellare gli account utente inutilizzati presenti in Active Directory

Lo script che verrà mostrato in quest'articolo consente di ricercare, all'interno di Active Directory, tutti gli account utente non utilizzati (in base alle condizioni specificate). La ricerca viene eseguita utilizzando il cmdlet Get-ADUser. I risultati saranno salvati all'interno di un file CSV e, con una semplice modifica (assegnando alla variabile $remove_unused_account il valore $true), sarà possibile fare in modo che gli account inutilizzati trovati vengano automaticamente eliminati da Active Directory (mediante il cmdlet Remove-ADUser).

Lo script può essere scaricato dal seguente link e le istruzioni sono ampiamente documentate  dalle righe di commenti.

Account utente inutilizzati
FIG 1 - Account utente inutilizzati




sabato 2 novembre 2019

Fogli Google: Ordinare i fogli in ordine alfabetico

Nell'articolo MS Excel: Ordinare i fogli in ordine alfabetico è stato mostrato come, attraverso l'utilizzo di VBA (Visual Basic for Application) sia possibile ordinare i fogli di una cartella di lavoro di un documento MS ExcelGoogle Docs (Documenti Google) non supporta VBA (proprietario di Microsoft) ma utilizza Google Apps Script: un linguaggio di scripting basato su JavaScript che gira nella cloud. In questo articolo mostrerò come creare uno script all'interno di Fogli Google che consenta di ordinare i fogli presenti all'interno del documento.

I passi da seguire sono semplici:
  • Creare un nuovo foglio di lavoro o aprirne uno già esistente accedendo a Google Docs tramite la pagina https://docs.google.com/spreadsheets/u/0/;
    Fogli Google, creare un nuovo foglio di lavoro
    FIG 1 - Fogli Google, creare un nuovo foglio di lavoro
  • Dal menu Strumenti selezionare Editor di script;
    Google Docs, Editor di script
    FIG 2 - Google Docs, Editor di script
  • Cliccare su Progetto senza titolo quindi assegnare un nome al progetto e cliccare su OK;
    Google Docs, Nome Progetto
    FIG 3 - Google Docs, Nome Progetto
  • Copiare e incollare il seguente codice;
    function onOpen() {
      SpreadsheetApp.getUi().createMenu('Ordina Fogli')
        .addItem('Ordina dalla A alla Z', 'sortAtoZ')
        .addItem('Ordina dalla Z alla A', 'sortZtoA')
        .addItem('Ripristina ordine prec.', 'ripristina')
        .addToUi();
    }
    
    function sortAtoZ() {
      var ss = SpreadsheetApp.getActiveSpreadsheet(), old = [];  
      ss.getSheets().map ( function (d) {
        var name = d.getName();
        old.push(name);
        return name;
      }).sort().reduce ( function  (arr, e, j) {
        ss.setActiveSheet(ss.getSheetByName(e));
        ss.moveActiveSheet(j + 1);
        return arr;
      }, []);
      PropertiesService.getScriptProperties().setProperty('old', JSON.stringify(old));
    }
    
    function sortZtoA() {
      var ss = SpreadsheetApp.getActiveSpreadsheet(), old = [];  
      ss.getSheets().map ( function (d) {
        var name = d.getName();
        old.push(name);
        return name;
      }).sort().reverse().reduce ( function  (arr, e, j) {
        ss.setActiveSheet(ss.getSheetByName(e));
        ss.moveActiveSheet(j + 1);
        return arr;
      }, []);
      PropertiesService.getScriptProperties().setProperty('old', JSON.stringify(old));
    }
    
    function ripristina(range) {
      var ss = SpreadsheetApp.getActiveSpreadsheet();
      var range = JSON.parse(PropertiesService.getScriptProperties().getProperty('old'));  
      range.reduce ( function  (arr, e, j) {
        ss.setActiveSheet(ss.getSheetByName(e));
        ss.moveActiveSheet(j + 1);
        return arr;
      }, []);
    }
    
  • Cliccare sul pulsante che rappresenta un insetto per eseguire il debug e il salvataggio del progetto e seguire le istruzioni a video per autenticare/autorizzare lo script;
    Google Docs, script debug
    FIG 4 - Google Docs, script debug
  • Chiudere e riaprire il foglio di lavoro. Apparirà un nuovo menu Ordina Fogli che consentirà di ordinare i fogli in maniera crescente (dalla A alla Z), decrescente (dalla Z alla A) o ripristinare l'ordine precedente all'ultima modifica.
    Google Docs, nuovo menu Ordina Fogli
    FIG 5 - Google Docs, nuovo menu Ordina Fogli


Come visibile dallo script, i nomi dei fogli vengono considerati come stringhe, ciò significa che se i nomi sono numeri questi vengono ordinati considerando l'ordine alfabetico e non il loro valore numerico.

Dal seguente link è possibile scaricare un file di testo contenente il codice dello script
DOWNLOAD






lunedì 23 settembre 2019

PowerShell: Creare una GUI per uno script PowerShell

Gli script PowerShell vengono generalmente creati ed eseguiti all'interno di un'interfaccia a riga di comando e anche i risultati vengono visualizzati all'interno della finestra CLI (Command Line Interface). Ciò ne scoraggia l'utilizzo da parte degli utenti comuni. Tuttavia, PowerShell è un potente strumento di automazione e consente l'utilizzo di una varietà di oggetti .NET Framework. Per creare una semplice interfaccia grafica per gli script PowerShell basta utilizzare l'API .NET.

In quest'articolo verrà mostrato come creare un semplice Form. Prima di iniziare assicurarsi che la versione di PowerShell installata sul proprio sistema sia 3.0 o superiore. Per farlo basta eseguire $PSVersionTable.PSVersion da una finestra PowerShell per visualizzare un'output come quello mostrato in FIG 1. Se la variabile non esiste allora probabilmente si tratta della versione 1.0

Versioni di PowerShell:
  • Versione 1.0: distribuita nel 2006 come download opzionale. Obsoleta
  • Versione 2.0: distribuita nel 2009 come parte di Windows 7/Windows Server 2008. L'unica versione che supporta Windows XP e Windows Server 2003.
  • Versione 3.0: distribuita nel 2012 come parte di Windows 8/Windows Server 2012. Sono state completate le caratteristiche principali del linguaggio ed è stato riprogettato l'editor ISE.
  • Versione 4.0: distribuita nel 2013 come parte di Windows 8.1/Windows Server 2012R2. Aggiunto DSC (Desired State Configuration).
  • Versione 5.0: distribuita nel 2016 come parte di Windows 10. In tale versione sono state introdotte numerose funzionalità ed estensioni.
  • Versione 5.1: distribuita nel 2017 come parte di Windows 10 Anniversary Update\Windows Server 2016.

PowerShell, visualizzare la versione installata nel sistema
FIG 1 - PowerShell, visualizzare la versione installata nel sistema
Il blocco di codice per creare un semplice Form è il seguente:

Add-Type -assembly System.Windows.Forms
$form = New-Object System.Windows.Forms.Form
$form.Text ='La mia finestra in PowerShell'
$form.Width = 400
$form.Height = 200
$form.AutoSize = $true
$form.ShowDialog()

Per la creazione del Form viene utilizzata la classe System.Windows.Forms di .NET. Per caricare tale classe all'interno dello script PowerShell si utilizza tale codice:
Add-Type -assembly System.Windows.Forms

Nell'istruzione successiva 
$form = New-Object System.Windows.Forms.Form
viene avviata una nuova istanza della classe System.Windows.Forms.Form di .NET Framework che genera una finestra vuota (Form o modulo) in cui è possibile iniziare ad aggiungere controlli.

Successivamente viene impostato un titolo per la finestra attraverso la proprietà Text, quindi vengono impostate le dimensioni (larghezza e altezza) tramite le proprietà Width e Height
$form.Text ='La mia finestra in PowerShell'
$form.Width = 400
$form.Height = 200

Per fare in modo che il Form si ridimensioni automaticamente in base al suo contenuto viene utilizzata la proprietà AutoSize.
$form.AutoSize = $true

L'ultima istruzione 
$form.ShowDialog()
non fa altro che richiamare il metodo ShowDialog per visualizzare a video il Form.

Per creare lo script basta copiare il blocco di codice sopra indicato all'interno di un editor di testo (come ad es. Blocco Note) e salvare il file con estensione .ps1 (ad es. Form1.ps1). Per eseguirlo da PowerShell digitare il nome del file .ps1 comprensivo del percorso (ad es. c:\Users\glubrano\desktop\Form1.ps1). Il risultato sarà quello mostrato in FIG 2.

Dal seguente link è possibile scaricare il file contenente il blocco di codice.
DOWNLOAD Form1.ps1
Form in PowerShell
FIG 2 - Form in PowerShell



Il Form così creato serve a ben poco. Possiamo aggiungere altri elementi come un etichette (label), una casella combinata (combobox) e un pulsante (button). Quello che andremo a costruire nelle prossime righe è uno script PowerShell che permette di selezionare, all'interno della combobox, una specifica cartella e, cliccando sul pulsante, visualizzarne la data dell'ultima modifica.

Iniziamo ad inserire un etichetta. Per farlo basta aggiungere il seguente blocco di codice prima dell'ultima istruzione $form.ShowDialog().

$Label1 = New-Object System.Windows.Forms.Label
$Label1.Text = "Directory:"
$Label1.Location  = New-Object System.Drawing.Point(5,10)
$Label1.AutoSize = $true
$form.Controls.Add($Label1)

Con la prima istruzione viene creata una nuova istanza della classe System.Windows.Forms.Label che genera l'etichetta. Successivamente viene specificato il testo che l'etichetta andrà a visualizzare quindi, tramite System.Drawing.Point(5,10) andiamo a specificare la posizione, all'interno del Form, in cui verrà visualizzata l'etichetta. Anche in questo caso viene impostata la proprietà AutoSize in modo che le dimensioni dell'elemento si adeguano in base al contenuto. 
L'ultima istruzione 
$form.Controls.Add($Label1)
aggiunge l'etichetta al form precedentemente creato.


Il passo successivo consiste nell'inserire una casella combinata accanto all'etichetta. Aggiungiamo il seguente blocco di codice al nostro file .PS1 (assicurandoci che l'ultima istruzione sia sempre $form.ShowDialog()) .

$ComboBox1 = New-Object System.Windows.Forms.ComboBox
$ComboBox1.Width = 150
$Folders = get-childitem -dir | Select Name
Foreach ($Folder in $Folders){
 $ComboBox1.Items.Add($Folder.Name);
}
$ComboBox1.Location  = New-Object System.Drawing.Point(60,10)
$form.Controls.Add($ComboBox1)

In questo blocco gran parte delle istruzioni sono analoghe a quanto visto per i blocchi precedenti. Con l'istruzione
$Folders = get-childitem -dir | Select Name
andiamo ad assegnare alla variabile $Folders l'elenco delle directory presenti nel path da cui stiamo richiamando lo script. Il ciclo ForEach non fa altro che estrarre il nome delle directory e inserirle all'interno della combobox.


Il blocco successivo provvede ad inserire all'interno del Form due etichette: Label2 e Label3. Quest'ultima mostrerà la data dell'ultima modifica della cartella selezionata quando si clicca sul pulsante presente alla destra della combobox.

$Label2 = New-Object System.Windows.Forms.Label
$Label2.Text = "Data modifica:"
$Label2.Location  = New-Object System.Drawing.Point(5,40)
$Label2.AutoSize = $true
$form.Controls.Add($Label2)

$Label3 = New-Object System.Windows.Forms.Label
$Label3.Text = ""
$Label3.Location  = New-Object System.Drawing.Point(90,40)
$Label3.AutoSize = $true
$form.Controls.Add($Label3)

Blocco codice relativo al pulsante. 

$Button1 = New-Object System.Windows.Forms.Button
$Button1.Location = New-Object System.Drawing.Point(220,10)
$Button1.Size = New-Object System.Drawing.Size(150,20)
$Button1.Text = "Visualizza data modifica"
$form.Controls.Add($Button1)

Anche questi 2 blocchi vanno inseriti prima dell'istruzione $form.ShowDialog(). Nel blocco relativo al pulsante troviamo l'istruzione 
$Button1.Size = New-Object System.Drawing.Size(120,20)
che consente di specificare la dimensione dell'elemento.

Adesso non resta che inserire un'ultimo blocco in cui andiamo ad aggiungere un evento relativo al click sul pulsante. 

$Button1.Add_Click(
 {
  $Label3.Text =  (get-item  $ComboBox1.selectedItem).LastWriteTime 
 }
)

L'istruzione
$Label3.Text =  (get-item  $ComboBox1.selectedItem).LastWriteTime 
rileva la data di modifica della directory selezionata all'interno della combobox e la visualizza attraverso la Label3.

L'intero script può essere scaricato dal seguente link
DOWNLOAD Form2.ps1

Eseguendo lo script, l'output sarà simile a quello mostrato in FIG 3.
PowerShell, Visualizzare la data di modifica di una data cartella attraverso il Form
FIG 3 - PowerShell, Visualizzare la data di modifica di una data cartella attraverso il Form


In modo analogo possono essere inseriti ulteriori elementi all'interno del Form come:
- CheckBox
- ChekedListBox
- ContextMenu
- DateTimePicker
- GroupBox
- HScrollBar
- ListBox
- ListView
- Menu
- PictureBox
- ProgressBar
- RadioButton
- TabControl
- TextBox
- TrackBar
- TreeView
- VScrollBar


Per creare in maniera semplice Form accattivanti per script in PowerShell, è possibile usare l'editor online https://poshgui.com/Editor. Tale editor, attraverso una semplice interfaccia grafica, consente di progettare/realizzare una GUI per i propri script PowerShell anche a chi è poco pratico e scaricare il codice sorgente.
POSHGUI, Editor online GUI PowerShell
FIG 4 - POSHGUI, Editor online GUI PowerShell