Visualizzazione post con etichetta C#. Mostra tutti i post
Visualizzazione post con etichetta C#. Mostra tutti i post

domenica 7 maggio 2017

C#: Elencare i file PST connessi ad Outlook

Per poter utilizzare Outlook è necessario disporre di un account di posta (Microsoft Exchange, POP o IMAP). L'account di posta è composto da un'oggetto di tipo Store che viene utilizzato per memorizzare i dati. Lo Store, a sua volta, è composto da cartelle e Item (come e-mail, contatti, appuntamenti, ecc). Anche un file archivio (file PST) è composto da un'oggetto di tipo Store. Per chiarire il concetto, si veda la seguente figura.


Outlook Store
FIG 1 - Outlook Store


In questo articolo verrà mostrato come, utilizzando C#, è possibile ottenere l'elenco dei file PST connessi ad Outlook.
Per poter interagire con gli oggetti di Outlook è necessario utilizzare, all'interno della nostra applicazione, il namespace Microsoft.Office.Interop.Outlook.

Una volta aggiunti i riferimenti a Microsoft.Office.Interop.Outlook, la prima operazione da effettuare è quella di creare un oggetto Outlook Application.
Outlook.Application olApp = new Outlook.Application();

Tale oggetto può essere utilizzato per diversi scopi, noi lo useremo per accedere agli altri oggetti di Outlook sottostanti.

Il nostro obiettivo è quello di accedere agli Store. Tale operazione è possibile attraverso l'oggetto NameSpace che contiene la sessione di collegamento ad Outlook
Outlook.NameSpace olNs=olApp.Session;
Outlook.Stores olStores=olNs.Stores;

A questo punto in olStores abbiamo tutti gli Store del profilo Outlook. Attraverso un ciclo For andiamo ad analizzare ciascun Store e verificare se si tratta di un file di dati (olStore.IsDataFileStore) e se la sua estensione è .PST (olStore.FilePath.ToString().ToUpper().EndsWith(".PST"). In caso affermativo il nome del file, comprensivo di path, verrà accodato ad una variabile stringa (pstList) che, al termine, conterrà l'elenco di tutti i file PST connessi ad Outlook
for (int i = 1; i <= olStores.Count; i++){
 olStore=olStores[i];
 if(olStore.IsDataFileStore){ //se si tratta di un file di dati
  if ((olStore.FilePath.ToString().ToUpper().EndsWith(".PST")) ){
   count++;
   pstList += String.Format("{0}. {1}{2}",count,olStore.FilePath,Environment.NewLine);
  }
    
 }
 if (olStore !=null)
  Marshal.ReleaseComObject(olStore);

 }

Alla fine non resta che chiudere le sessioni e rilasciare gli oggetti.
if (olStores !=null)
 Marshal.ReleaseComObject(olStores);
if (olStore !=null)
 Marshal.ReleaseComObject(olStore);
if (olApp !=null)
 Marshal.ReleaseComObject(olApp);
if (olNs != null)
 Marshal.ReleaseComObject(olNs);

Per chi vuole può scaricare il codice sorgente dell'esempio dal seguente link.
DOWNLOAD



lunedì 16 gennaio 2017

C#: Oscurare il monitor utilizzando le API di Windows

In questo articolo verrà mostrato come gestire il monitor e oscurarlo tramite l'utilizzo di C# e le API (Application Programming Interface) di Windows. Per la gestione del monitor tramite C# è possibile utilizzare la funzione PostMessage(). Tale funzione invia il messaggio specificato alla coda associata al thread che ha generato la finestra, quindi esce senza aspettare che il messaggio venga processato.

La prima operazione da eseguire consiste nel dichiarare la funzione PostMessage() all'interno del codice. In Visual C# questo avviene con le seguenti righe di codice
[DllImport("user32.dll", SetLastError = true)]
static extern bool PostMessage(IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam);

I parametri di PostMessage() sono:
hWnd - rappresenta l'Handle della finestra che riceve il messaggio;
Msg - specifica il messaggio da inviare alla finestra;
wParam - permette di specificare informazioni aggiuntive relative al messaggio;
lParam - specifica lo stato del monitor.


hWnd - Handle della finestra

Per quanto riguarda l'handle da passare alla funzione ci sono diverse possibilità. Nel caso di applicazioni basate su finestre è possibile utilizzare l'handle della finestra corrente: this.Handle.
All'interno di librerie dll o di applicazioni console, invece, è possibile utilizzare delle costanti come indicato su MSDN: 0xFFFF  per inviare il messaggio a tutte le finestre superiori oppure -1 per inviare il messaggio alla finestra superiore a tutte le altre. 

In alternativa si può ricercare l'handle di una finestra aperta utilizzando la seguente funzione
[DllImport("user32.dll", SetLastError = true)]
static extern IntPtr FindWindow(string lpClassName, string lpWindowName);
La funzione recupera l'handler della finestra superiore al form la cui classe è indicata da lpClassName e nella barra del titolo è presente la stringa lpWindowName. Passando null ad entrambi i parametri della funzione verrà recuperato l'handle della finestra superiore a tutte le altre.



Msg - Messaggio da inviare alla finestra

Dopo l'handler è necessario specificare il messaggio da inviare alla finestra. Per il messaggio è possibile utilizzare la costante 0x0112 che indica un comando di sistema. Il valore, all'interno del codice allegato all'articolo, è rappresentato dalla seguente costante:
const int WM_SYSCOMMAND = 0x0112;



wParam - Informazioni aggiuntive relative al messaggio

Al parametro wParam viene passato il valore 0xF170 che permette la gestione dell'alimentazione del monitor. All'interno del codice tale parametro viene passato utilizzando la costante SC_MONITORPOWER.


lParam - Stato del monitor

L'ultimo parametro da specificare è lParam che indica lo stato in cui impostare il monitor: -1 per accesso, 2 per spento, 1 per standby. 


C#, Oscurare lo schermo tramite PostMessage()
FIG 1 - C#, Oscurare lo schermo tramite PostMessage()


Di seguito è possibile scaricare i file sorgenti del progetto. Il progetto può essere aperto e modificato tramite Visual Studio oppure tramite ambienti di sviluppo di terze parti come ad es. SharpDevelop
DOWNLOAD
Turn Off Screen
FIG 2 - Turn Off Screen



Al posto di PostMessage() è possibile utilizzare anche altri funzioni API come SendMessage(), PostThreadMessage(), SendNotifyMessage() e SendMessageCallback().

SendMessage()
Invia il messaggio ad una o più finestre e attende che venga processato.
[DllImport("user32.dll")]
static extern IntPtr SendMessage(IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam);

  
PostThreadMessage()
Inserisce il messaggio all'interno della coda del thread specificato. Anche in questo caso la funzione termina senza attendere che il thread processi il messaggio.
[DllImport("user32.dll")]
static extern bool PostThreadMessage(uint idThread, uint Msg, UIntPtr wParam, IntPtr lParam);

 
SendNotifyMessage()
Invia il messaggio ad una o più finestre. Se la finestra è stata creata dal thread chiamato, SendNotifyMessage chiama la routine della specifica finestra e non termina finchè il messaggio non è stato processato. Se la finestra è stata creata da un thread diverso, SendNotifyMessage passa il messaggio alla routine delle finestre e termina senza attendere l'esecuzione del messaggio.
[DllImport("user32.dll", SetLastError=true, CharSet=CharSet.Auto)]
static extern bool SendMessageCallback(IntPtr hWnd, uint Msg,UIntPtr wParam, IntPtr lParam, SendMessageDelegate lpCallBack,
                                       UIntPtr dwData);

  
SendMessageCallback()
Richiama la routine della finestra specificata e termina immediatamente. Dopo che la routine ha processato il messaggio, il sistema chiama la funzione di callback specificata passandole il risultato dell'elaborazione.    
[DllImport("user32.dll", SetLastError=true, CharSet=CharSet.Auto)]
static extern bool SendNotifyMessage(IntPtr hWnd, uint Msg, UIntPtr wParam, IntPtr lParam);

  

lunedì 20 aprile 2015

C# : Verificare la versione di Outlook installata

In questo articolo mostrerò come individuare la versione di Microsoft Outlook installata, sulla propria postazione o su una workstation remota, utilizzando C#
L'operazione può essere effettuata in modi diversi e l'applicazione che ho creato è molto semplice e offre ampi margini di miglioramento. Quello che andrò a fare è semplicemente verificare la versione del file Outlook.exe
OutlookVer
FIG 1 - OutlookVer

Come primo passo chiedo all'utente se intende verificare la versione di Outlook installata sulla workstation locale o su una workstation remota. Nel caso di postazione remota verifico se la postazione è raggiungibile.
Il passo successivo consiste nell'individuare il path (percorso) del file Outlook.exe. Per conoscere il path di installazione di outlook vado ad interrogare il valore stringa Path presente nella seguente chiave di registro
HKLM\Software\Microsoft\Windows\CurrentVersion\App Paths\OUTLOOK.EXE

Per la workstation locale utilizzo l'istruzione 
RegistryKey.OpenBaseKey(RegistryHive.LocalMachine,RegistryView.Registry32).OpenSubKey(RegKey);
mentre per verificare una postazione remota utilizzo l'istruzione
RegistryKey.OpenRemoteBaseKey(RegistryHive.CurrentUser, textBoxWKSName.Text).OpenSubKey(RegKey);

Una volta individuato il path del file Outlook.exe, verifico la sua versione tramite l'istruzione 
FileVersionInfo.GetVersionInfo(_path)

A questo punto non resta che visualizzare a video un messaggio con la versione di Outlook installata
Versione di Outlook
FIG 2 - Versione di Outlook
Di seguito è possibile scaricare i file sorgenti del progetto. Il progetto può essere aperto e modificato tramite Visual Studio oppure tramite ambienti di sviluppo di terze parti come ad es. SharpDevelop
DOWNLOAD