Microsoft Graph per gestire le caselle di posta in C#

L’integrazione dell’API Microsoft Graph e della libreria Aspose.Email per .NET con un’applicazione email consente agli sviluppatori di accedere e manipolare facilmente i dati della casella di posta, eseguire operazioni come il recupero di messaggi, la recupero di gerarchie di cartelle e il salvataggio di email in diversi formati. In questo articolo, esploreremo come sfruttare questa potente combinazione per elaborare e gestire le caselle di posta.

Presentazione di Microsoft Graph

Microsoft Graph è una piattaforma API completa fornita da Microsoft che offre un endpoint unificato per accedere a una vasta gamma di servizi e dati Microsoft. Funziona come un gateway ai vasti dati disponibili in Microsoft 365, inclusi le caselle di posta di Outlook, i calendari, i contatti, OneDrive, Teams e altro ancora.

Con Microsoft Graph, gli sviluppatori possono creare applicazioni che interagiscono senza soluzione di continuità con i dati e le intuizioni degli utenti all’interno dell’ecosistema cloud di Microsoft. Questo è realizzato attraverso API RESTful e SDK che forniscono i mezzi per autenticare, autorizzare e interrogare i dati con facilità.

Informazioni sulla libreria Aspose.Email per .NET

Aspose.Email per .NET è una libreria ricca di funzionalità che consente agli sviluppatori di lavorare con file e protocolli email nelle loro applicazioni .NET. Fornisce un robusto set di API per creare, manipolare e convertire messaggi email in vari formati, come MSG, EML e MBOX. Inoltre, la libreria supporta protocolli email come SMTP, POP3 e IMAP, consentendo una gestione versatile delle email.

In questa guida, utilizzeremo Aspose.Email per interagire con Microsoft Graph, elaborando i dati della casella di posta programmaticamente. Con il GraphClient di Aspose.Email, possiamo eseguire in modo efficiente operazioni sulla casella di posta autenticandoci con Microsoft Graph.

Per iniziare a utilizzare la libreria, devi integrarla nel tuo progetto. Il modo più semplice per ottenere Aspose.Email per .NET è tramite il NuGet Package Manager:

  • Apri il tuo progetto in Visual Studio.
  • Naviga su Strumenti > NuGet Package Manager > Gestisci Pacchetti NuGet per la Soluzione.
  • Cerca Aspose.Email.
  • Seleziona il pacchetto e fai clic su Installa.

In alternativa, puoi utilizzare la Console del Package Manager:

Install-Package Aspose.Email

Puoi anche scaricare l’ultima versione dell’API direttamente dal sito di Aspose.

Configura la tua app nel portale Azure

Prima di immergerci nel codice, è fondamentale configurare la tua applicazione all’interno del portale Azure per abilitare l’accesso a Microsoft Graph. Segui semplicemente questi passaggi:

  1. Crea un’applicazione Azure Active Directory (AAD):

    • Naviga al Portale Azure.
    • Vai su Azure Active Directory > Registrazioni delle app.
    • Fai clic su Nuova registrazione per creare una nuova applicazione.
    • Fornisci un nome e imposta l’URI di reindirizzamento se necessario.
    • Fai clic su Registrati per completare il processo.

  2. Imposta le autorizzazioni API:

    • Nella tua app registrata, vai su Autorizzazioni API.
    • Fai clic su Aggiungi un’autorizzazione > Microsoft Graph.
    • Seleziona Autorizzazioni per l’applicazione per chiamate server-to-server.
    • Scegli le autorizzazioni necessarie come Mail.Read, Mail.ReadWrite, User.Read, ecc.
    • Fai clic su Aggiungi autorizzazioni per applicare.

  3. Crea un Segreto del Client:

    • Vai su Certificati e segreti nella tua app.
    • Fai clic su Nuovo segreto cliente e fornisci una descrizione.
    • Imposta un periodo di scadenza, quindi fai clic su Aggiungi.
    • Prendi nota del valore del segreto cliente generato, poiché ne avrai bisogno in seguito.

  4. Raccogli i Valori di Configurazione:

    • Ottieni l’ID del Tenant, l’ID del Client e il Segreto del Client dalla pagina di panoramica della tua app e dalla sezione segreti.
    • Utilizzerai questi valori per autenticarti e interagire con Microsoft Graph.

Una volta configurata la tua applicazione, sei pronto a procedere con i compiti di sviluppo.

Ottieni il Token di Accesso e Inizializza GraphClient

Prima di immergerci nelle operazioni sulla casella di posta, dobbiamo aprire la porta all’ampio ecosistema di dati e servizi di Microsoft Graph. Questo accesso è garantito attraverso un token di accesso OAuth 2.0 - una chiave digitale che autorizza la tua applicazione a interagire con Microsoft Graph per conto di un utente o di un servizio. Immaginalo come un pass sicuro che ti concede l’accesso a un intero universo di possibilità, dal recupero di email alla gestione dei contatti e oltre.

Passo 1: Imposta un file di configurazione

Il primo passo per acquisire il token è impostare un file di configurazione che memorizzi dettagli essenziali come l’ID del Tenant, l’ID del Client e il Segreto del Client della tua applicazione. Questi valori sono le credenziali della tua applicazione e fungono da identificatori quando comunichi con i server Microsoft.

Ecco come potrebbe apparire la tua configurazione JSON:

{
    "Instance": "https://login.microsoftonline.com/{0}",
    "ApiUrl": "https://graph.microsoft.com/.default",
    "TenantId": "YOUR_TENANT_ID_HERE",
    "ClientId": "YOUR_APP_ID_HERE",
    "ClientSecret": "YOUR_CLIENT_SECRET_HERE",
    "UserId": "YOUR_ID_HERE"
}

Passo 2: Mappa la configurazione JSON a un oggetto C#

Ora, trasformiamo questa configurazione in un oggetto C# che la nostra applicazione può utilizzare. Leggeremo il file JSON e mapperemo i suoi contenuti a una classe AuthenticationConfig, assicurandoci che la nostra applicazione sappia dove trovare le informazioni critiche di cui ha bisogno.

class AuthenticationConfig
{
    public string Instance { get; set; }
    public string ApiUrl { get; set; }
    public string TenantId { get; set; }
    public string ClientId { get; set; }
    public string UserId { get; set; }
    public string Authority => string.Format(CultureInfo.InvariantCulture, Instance, TenantId);
    public string ClientSecret { get; set; }
    
    public static AuthenticationConfig ReadFromJsonFile(string path)
    {
        var builder = new ConfigurationBuilder()
            .SetBasePath(Directory.GetCurrentDirectory())
            .AddJsonFile(path);

        var configuration = builder.Build();
        return configuration.Get<AuthenticationConfig>();
    }
}

Passo 3: Acquisisci il Token di Accesso

Con la nostra configurazione in atto, è il momento di acquisire il token di accesso. Implementeremo una classe GraphTokenProvider che gestisce il processo di autenticazione utilizzando la Microsoft Authentication Library (MSAL). Questa classe si occupa del lavoro pesante - comunicare con Microsoft Graph per ottenere il token che potenzia la nostra applicazione.

class GraphTokenProvider : ITokenProvider
{
    private readonly IConfidentialClientApplication _app;
    private readonly string[] _scopes;
    private string? _token;
    
    public GraphTokenProvider(AuthenticationConfig config)
    {
        _app = ConfidentialClientApplicationBuilder.Create(config.ClientId)
            .WithClientSecret(config.ClientSecret)
            .WithAuthority(config.Authority)
            .Build();

        // Cache dei token in memoria (Cache dell'App e dell'Utente)
        _app.AddInMemoryTokenCache();
        
        _scopes = new[] { config.ApiUrl }; 
    }

    public void Dispose()
    {
        throw new NotImplementedException();
    }

    public OAuthToken GetAccessToken()
    {
        return GetAccessToken(false);
    }

    public OAuthToken GetAccessToken(bool ignoreExistingToken)
    {
        if (!ignoreExistingToken && _token != null)
        {
            return new OAuthToken(_token);
        }

        _token = GetAccessTokenAsync().GetAwaiter().GetResult();
        return new OAuthToken(_token);
    }
    
    private async Task<string?> GetAccessTokenAsync()
    {
        AuthenticationResult? result;
        
        try
        {
            result = await _app.AcquireTokenForClient(_scopes)
                .ExecuteAsync();
            
            Console.WriteLine($"Il token è stato acquisito da {result.AuthenticationResultMetadata.TokenSource} {Environment.NewLine}");
        }
        catch (MsalServiceException ex)
        {
            Console.WriteLine($"Errore nell'acquisire il Token:{Environment.NewLine}{ex}{Environment.NewLine}");
            result = null;
        }

        if (result == null) return null;
        _token = result.AccessToken;
        return result.AccessToken;
    }
}

Passo 4: Inizializza GraphClient

Infine, inizializziamo il GraphClient utilizzando il token che abbiamo acquisito. Il GraphClient funge da ponte verso Microsoft Graph, consentendoci di interagire con le caselle di posta degli utenti senza soluzione di continuità.

var config = AuthenticationConfig.ReadFromJsonFile("appsettings.json");
var tokenProvider = new GraphTokenProvider(config);

using var client = GraphClient.GetClient(tokenProvider, config.TenantId);
client.Resource = ResourceType.Users;
client.ResourceId = config.UserId;

Ottieni una Gerarchia di Cartelle e Recupera Cartelle per Nome

Una volta acquisito l’accesso a Microsoft Graph, è tempo di intraprendere un’esplorazione della casella di posta. In questa sezione, ci immergeremo nel recupero e nella navigazione della gerarchia delle cartelle di una casella di posta, consentendoti di accedere a cartelle specifiche per nome.

Passo 1: Comprendere la Gerarchia delle Cartelle

Le caselle di posta sono strutturate gerarchicamente, proprio come un albero. La cartella radice si ramifica in diverse sottocartelle, ognuna contenente il proprio set di email e potenzialmente altre sottocartelle. Questa struttura nidificata consente una gestione organizzata e una navigazione facile delle email.

Definiamo e utilizziamo la classe FolderNode per rappresentare ogni cartella nella gerarchia:

// Rappresenta un nodo in una gerarchia di cartelle,
// estendendo le proprietà di FolderInfo e memorizzando una collezione di sottocartelle.
class FolderNode
{
    // Ottiene l'oggetto FolderInfo che rappresenta le informazioni sulla cartella.
    public FolderInfo Folder { get; }
    
    // Ottiene la collezione di sottocartelle contenute nella cartella corrente.
    public List<FolderNode?> SubFolders { get; }

    // Inizializza una nuova istanza della classe FolderNode con l'oggetto FolderInfo specificato.
    public FolderNode(FolderInfo folder)
    {
        Folder = folder;
        SubFolders = new List<FolderNode?>();
    }
    
    // Stampa tutte le cartelle in modo gerarchico a partire dal nodo corrente.
    public void PrintHierarchy()
    {
        PrintFolderNode(this, 0);
    }

    private void PrintFolderNode(FolderNode node, int indentLevel)
    {
        // Stampa il nodo della cartella corrente con indentazione
        Console.WriteLine($"{new string(' ', indentLevel * 2)}{node}");

        // Stampa ricorsivamente le sottocartelle
        foreach (var subFolder in node.SubFolders)
        {
            PrintFolderNode(subFolder, indentLevel + 1);
        }
    }

    // Ottiene il nome visualizzato della cartella.
    public override string ToString()
    {
        return $"{Folder.DisplayName} ({Folder.ContentCount})";
    }
}

Per recuperare la gerarchia completa delle cartelle, creeremo la classe FolderHierarchy, che sfrutta il GraphClient per elencare tutte le cartelle in modo ricorsivo. Ecco come funziona:

static class FolderHierarchy
{
    // Recupera tutte le cartelle nella casella di posta in modo ricorsivo e restituisce una collezione gerarchica di oggetti FolderNode.
    public static List<FolderNode> Retrieve(IGraphClient client)
    {
        // Recupera le cartelle radice
        var rootFolders = client.ListFolders();
        var allFolders = new List<FolderNode>();

        // Recupera le sottocartelle in modo ricorsivo
        foreach (var folder in rootFolders)
        {
            var folderNode = new FolderNode(folder);
            RetrieveSubFolders(client, folderNode);
            allFolders.Add(folderNode);
        }

        return allFolders;
    }

    // Recupera le sottocartelle in modo ricorsivo e le aggiunge alla proprietà SubFolders del nodo della cartella padre.
    private static void RetrieveSubFolders(IGraphClient client, FolderNode parentFolderNode)
    {
        if (parentFolderNode.Folder.HasSubFolders)
        {
            var subFolders = client.ListFolders(parentFolderNode.Folder.ItemId);
            
            foreach (var subFolder in subFolders)
            {
                var subFolderNode = new FolderNode(subFolder);
                RetrieveSubFolders(client, subFolderNode);
                parentFolderNode.SubFolders.Add(subFolderNode);
            }
        }
    }
}

Passo 2: Recupera la Gerarchia delle Cartelle

Utilizzando il metodo FolderHierarchy.Retrieve, puoi facilmente esplorare la casella di posta per scoprire la sua struttura di cartelle. Ecco come puoi farlo:

// Recupera la gerarchia delle cartelle dalla casella di posta
var folderNodes = FolderHierarchy.Retrieve(client);

// Stampa la gerarchia delle cartelle in un formato strutturato
foreach (var folderNode in folderNodes)
{
    folderNode.PrintHierarchy();
}

Passo 3: Recupera Cartelle per Nome

Una volta recuperata la gerarchia delle cartelle, puoi individuare cartelle specifiche per nome. Che tu sia interessato ad accedere alla Posta in Arrivo o a qualsiasi cartella personalizzata, questo metodo assicura che tu possa trovarle rapidamente:

// Specifica il nome della cartella che stai cercando
string targetFolderName = "Posta in Arrivo";

// Individua la cartella target per nome
var targetFolder = folderNodes.FirstOrDefault(
    folderNode => folderNode.Folder.DisplayName.Equals(targetFolderName, StringComparison.OrdinalIgnoreCase))
    ?.Folder;

Elenca Messaggi nella Cartella Specificata

Con la gerarchia delle cartelle recuperata con successo, il passo successivo è immergersi nel contenuto di cartelle specifiche. Immagina di aver navigato nella tua Posta in Arrivo; ora vuoi visualizzare tutti i messaggi che contiene.

In questa sezione, esploreremo come elencare i messaggi all’interno di una cartella specifica utilizzando il GraphClient e Aspose.Email per .NET.

Una volta che hai la cartella, l’elenco dei messaggi al suo interno è semplice. Il GraphClient fornisce un metodo ListMessages per recuperare tutti i messaggi in una cartella, che puoi quindi elaborare o visualizzare.

Ecco il codice per elencare i messaggi dalla cartella specificata:

Console.WriteLine("Elenco dei messaggi nella cartella specificata...");

// Chiama il metodo del client per elencare i messaggi nella cartella selezionata
var messageInfoCollection = client.ListMessages(targetFolder.ItemId);

Console.WriteLine($"{targetFolderName}:");

// Stampa le linee dell'oggetto dei messaggi
foreach (var messageInfo in messageInfoCollection)
{
    Console.WriteLine($"     - {messageInfo.Subject}");
}

La messageInfoCollection contiene dettagli essenziali su ciascuna email. Queste informazioni possono essere utilizzate per visualizzare riepiloghi, generare report o persino attivare avvisi in base a criteri specifici.

Conclusione

In questo articolo, abbiamo esplorato come sfruttare la potenza di Microsoft Graph e della libreria Aspose.Email per .NET per elaborare efficacemente le caselle di posta, navigare nelle gerarchie di cartelle e elencare i messaggi all’interno di cartelle specifiche. Seguendo questi passaggi, puoi costruire applicazioni robuste che interagiscono senza problemi con i dati email, fornendo funzionalità e esperienze utente migliorate.

Concetti in Azione

Se sei ansioso di vedere questi concetti in azione, puoi scaricare un esempio completamente funzionale di un’applicazione in esecuzione. Questa applicazione include il codice sorgente descritto in questo articolo e dimostra come implementare queste funzionalità passo dopo passo.

Visita il nostro repository GitHub per accedere all’applicazione di esempio: Aspose.Email per .NET - Esempio GraphApp.

Elaborare le caselle di posta tramite Microsoft Graph offre accesso senza pari ai dati email e capacità di gestione. Con gli strumenti e le tecniche giuste, puoi costruire applicazioni sofisticate che forniscono intuizioni significative e automatizzano compiti complessi, migliorando in ultima analisi la produttività e la soddisfazione dell’utente.

Provalo Gratis

Inoltre, Aspose.Email fornisce una documentazione completa documentazione, un’ampia riferimento API e una varietà di strumenti online gratuiti e app per migliorare il tuo processo di sviluppo. Gli sviluppatori possono anche accedere a un libero forum di supporto per assistenza e intuizioni dalla comunità e rimanere aggiornati con gli ultimi suggerimenti e tutorial tramite il blog di Aspose blog.

Vedi Anche