Microsoft Graph pour gérer les boîtes aux lettres en C#

L’intégration de l’API Microsoft Graph et de la bibliothèque Aspose.Email pour .NET avec une application de messagerie permet aux développeurs d’accéder et de manipuler facilement les données de la boîte aux lettres, d’effectuer des opérations telles que la récupération de messages, la récupération de hiérarchies de dossiers et l’enregistrement d’e-mails dans différents formats. Dans cet article, nous allons explorer comment tirer parti de cette combinaison puissante pour traiter et gérer les boîtes aux lettres.

Présentation de Microsoft Graph

Microsoft Graph est une plateforme API complète fournie par Microsoft qui offre un point de terminaison unifié pour accéder à une large gamme de services et de données Microsoft. Elle sert de passerelle à l’immense quantité de données disponibles dans Microsoft 365, y compris les boîtes aux lettres Outlook, les calendriers, les contacts, OneDrive, Teams et plus encore.

Avec Microsoft Graph, les développeurs peuvent créer des applications qui interagissent sans effort avec les données utilisateur et les informations au sein de l’écosystème cloud de Microsoft. Cela est réalisé grâce à des API RESTful et des SDK qui fournissent les moyens d’authentifier, d’autoriser et de consulter les données facilement.

À propos de la bibliothèque Aspose.Email pour .NET

Aspose.Email pour .NET est une bibliothèque riche en fonctionnalités qui permet aux développeurs de travailler avec des fichiers et des protocoles de messagerie dans leurs applications .NET. Elle fournit un ensemble robuste d’API pour créer, manipuler et convertir des messages électroniques dans divers formats, tels que MSG, EML et MBOX. De plus, la bibliothèque prend en charge des protocoles de messagerie tels que SMTP, POP3 et IMAP, permettant une gestion polyvalente des e-mails.

Dans ce guide, nous utiliserons Aspose.Email pour interagir avec Microsoft Graph, en traitant les données de la boîte aux lettres par programmation. Avec le GraphClient d’Aspose.Email, nous pouvons effectuer efficacement des opérations sur les boîtes aux lettres en nous authentifiant auprès de Microsoft Graph.

Pour commencer à utiliser la bibliothèque, vous devez l’intégrer dans votre projet. La manière la plus simple d’obtenir Aspose.Email pour .NET est via le Gestionnaire de packages NuGet :

  • Ouvrez votre projet dans Visual Studio.
  • Accédez à Outils > Gestionnaire de packages NuGet > Gérer les packages NuGet pour la solution.
  • Recherchez Aspose.Email.
  • Sélectionnez le package et cliquez sur Installer.

Alternativement, vous pouvez utiliser la console du Gestionnaire de packages :

Install-Package Aspose.Email

Vous pouvez également télécharger la dernière version de l’API directement depuis le site web d’Aspose site.

Configurer votre application sur le portail Azure

Avant de plonger dans le code, il est crucial de configurer votre application dans le portail Azure pour permettre l’accès à Microsoft Graph. Suivez simplement ces étapes :

  1. Créer une application Azure Active Directory (AAD) :

    • Accédez au portail Azure.
    • Allez à Azure Active Directory > Enregistrements d’application.
    • Cliquez sur Nouvelle inscription pour créer une nouvelle application.
    • Fournissez un nom et définissez l’URI de redirection si nécessaire.
    • Cliquez sur Enregistrer pour terminer le processus.

  2. Définir les autorisations API :

    • Dans votre application enregistrée, accédez à Autorisations API.
    • Cliquez sur Ajouter une autorisation > Microsoft Graph.
    • Sélectionnez Autorisations d’application pour les appels serveur à serveur.
    • Choisissez les autorisations nécessaires comme Mail.Read, Mail.ReadWrite, User.Read, etc.
    • Cliquez sur Ajouter des autorisations pour appliquer.

  3. Créer un secret client :

    • Allez à Certificats et secrets dans votre application.
    • Cliquez sur Nouveau secret client et fournissez une description.
    • Définissez une période d’expiration, puis cliquez sur Ajouter.
    • Notez la valeur du secret client généré, car vous en aurez besoin plus tard.

  4. Rassembler les valeurs de configuration :

    • Obtenez le ID de locataire, ID client et Secret client de la page d’aperçu de votre application et de la section des secrets.
    • Vous utiliserez ces valeurs pour vous authentifier et interagir avec Microsoft Graph.

Une fois votre application configurée, vous êtes prêt à procéder aux tâches de développement.

Obtenir un jeton d’accès et initialiser GraphClient

Avant de plonger dans les opérations sur les boîtes aux lettres, nous devons déverrouiller l’accès à l’immense écosystème de données et de services de Microsoft Graph. Cet accès est accordé par un jeton d’accès OAuth 2.0 - une clé numérique qui autorise votre application à interagir avec Microsoft Graph au nom d’un utilisateur ou d’un service. Imaginez-le comme un pass sécurisé qui vous accorde l’entrée dans tout un univers de possibilités, de la récupération d’e-mails à la gestion des contacts et au-delà.

Étape 1 : Configurer un fichier de configuration

La première étape pour acquérir le jeton consiste à configurer un fichier de configuration qui stocke des détails essentiels tels que le ID de locataire, le ID client et le Secret client de votre application. Ces valeurs sont les identifiants de votre application lors de la communication avec les serveurs Microsoft.

Voici à quoi pourrait ressembler votre configuration JSON :

{
    "Instance": "https://login.microsoftonline.com/{0}",
    "ApiUrl": "https://graph.microsoft.com/.default",
    "TenantId": "VOTRE_ID_LOCATAIRE_ICI",
    "ClientId": "VOTRE_ID_APPLICATION_ICI",
    "ClientSecret": "VOTRE_SECRET_CLIENT_ICI",
    "UserId": "VOTRE_ID_ICI"
}

Étape 2 : Mapper la configuration JSON à un objet C#

Maintenant, transformons cette configuration en un objet C# que notre application peut utiliser. Nous allons lire le fichier JSON et mapper son contenu à une classe AuthenticationConfig, assurant que notre application sait où trouver les informations critiques dont elle a besoin.

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>();
    }
}

Étape 3 : Acquérir un jeton d’accès

Avec notre configuration en place, il est temps d’acquérir le jeton d’accès. Nous allons mettre en œuvre une classe GraphTokenProvider qui gère le processus d’authentification en utilisant la bibliothèque d’authentification Microsoft (MSAL). Cette classe s’occupe des tâches lourdes - communiquer avec Microsoft Graph pour obtenir le jeton qui habilite notre application.

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 de jetons en mémoire (Caches d'application et d'utilisateur)
        _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($"Le jeton acquis de {result.AuthenticationResultMetadata.TokenSource} {Environment.NewLine}");
        }
        catch (MsalServiceException ex)
        {
            Console.WriteLine($"Erreur lors de l'acquisition du jeton :{Environment.NewLine}{ex}{Environment.NewLine}");
            result = null;
        }

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

Étape 4 : Initialiser GraphClient

Enfin, nous initialisons le GraphClient en utilisant le jeton que nous avons acquis. Le GraphClient agit comme notre pont vers Microsoft Graph, nous permettant d’interagir sans effort avec les boîtes aux lettres des utilisateurs.

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;

Obtenir une hiérarchie de dossiers et récupérer des dossiers par nom

Une fois que vous avez acquis l’accès à Microsoft Graph, il est temps d’explorer la boîte aux lettres. Dans cette section, nous allons approfondir la récupération et la navigation dans la hiérarchie des dossiers d’une boîte aux lettres, vous permettant d’accéder à des dossiers spécifiques par leur nom.

Étape 1 : Comprendre la hiérarchie des dossiers

Les boîtes aux lettres sont structurées hiérarchiquement, un peu comme un arbre. Le dossier racine se divise en plusieurs sous-dossiers, chacun contenant son propre ensemble d’e-mails et potentiellement plus de sous-dossiers. Cette structure imbriquée permet une gestion organisée et une navigation facile des e-mails.

Définissons et utilisons la classe FolderNode pour représenter chaque dossier dans la hiérarchie :

// Représente un nœud dans une hiérarchie de dossiers,
// étendant les propriétés de FolderInfo et stockant une collection de sous-dossiers.
class FolderNode
{
    // Obtient l'objet FolderInfo représentant les informations sur le dossier.
    public FolderInfo Folder { get; }
    
    // Obtient la collection de sous-dossiers contenus dans le dossier actuel.
    public List<FolderNode?> SubFolders { get; }

    // Initialise une nouvelle instance de la classe FolderNode avec l'objet FolderInfo spécifié.
    public FolderNode(FolderInfo folder)
    {
        Folder = folder;
        SubFolders = new List<FolderNode?>();
    }
    
    // Imprime tous les dossiers de manière hiérarchique à partir du nœud actuel.
    public void PrintHierarchy()
    {
        PrintFolderNode(this, 0);
    }

    private void PrintFolderNode(FolderNode node, int indentLevel)
    {
        // Imprime le nœud de dossier actuel avec indentation
        Console.WriteLine($"{new string(' ', indentLevel * 2)}{node}");

        // Imprime récursivement les sous-dossiers
        foreach (var subFolder in node.SubFolders)
        {
            PrintFolderNode(subFolder, indentLevel + 1);
        }
    }

    // Obtenir le nom d'affichage du dossier.
    public override string ToString()
    {
        return $"{Folder.DisplayName} ({Folder.ContentCount})";
    }
}

Pour récupérer la hiérarchie complète des dossiers, nous allons créer la classe FolderHierarchy, qui utilise le GraphClient pour lister tous les dossiers de manière récursive. Voici comment cela fonctionne :

static class FolderHierarchy
{
    // Récupère tous les dossiers de la boîte aux lettres de manière récursive et renvoie une collection hiérarchique d'objets FolderNode.
    public static List<FolderNode> Retrieve(IGraphClient client)
    {
        // Récupérer les dossiers racines
        var rootFolders = client.ListFolders();
        var allFolders = new List<FolderNode>();

        // Récupérer les sous-dossiers de manière récursive
        foreach (var folder in rootFolders)
        {
            var folderNode = new FolderNode(folder);
            RetrieveSubFolders(client, folderNode);
            allFolders.Add(folderNode);
        }

        return allFolders;
    }

    // Récupère les sous-dossiers de manière récursive et les ajoute à la propriété SubFolders du nœud parent FolderNode.
    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);
            }
        }
    }
}

Étape 2 : Récupérer la hiérarchie des dossiers

En utilisant la méthode FolderHierarchy.Retrieve, vous pouvez facilement traverser la boîte aux lettres pour découvrir sa structure de dossiers. Voici comment vous pouvez réaliser cela :

// Récupérer la hiérarchie des dossiers de la boîte aux lettres
var folderNodes = FolderHierarchy.Retrieve(client);

// Imprimer la hiérarchie des dossiers dans un format structuré
foreach (var folderNode in folderNodes)
{
    folderNode.PrintHierarchy();
}

Étape 3 : Récupérer des dossiers par nom

Une fois la hiérarchie des dossiers récupérée, vous pouvez cibler des dossiers spécifiques par leur nom. Que vous soyez intéressé à accéder à la Boîte de réception ou à tout dossier personnalisé, cette méthode garantit que vous pouvez les localiser rapidement :

// Spécifiez le nom du dossier que vous recherchez
string targetFolderName = "Boîte de réception";

// Localisez le dossier cible par son nom
var targetFolder = folderNodes.FirstOrDefault(
    folderNode => folderNode.Folder.DisplayName.Equals(targetFolderName, StringComparison.OrdinalIgnoreCase))
    ?.Folder;

Lister les messages dans le dossier spécifié

Avec la hiérarchie des dossiers récupérée avec succès, l’étape suivante consiste à plonger dans le contenu de dossiers spécifiques. Imaginez que vous avez navigué jusqu’à votre Boîte de réception; maintenant, vous voulez voir tous les messages qu’elle contient.

Dans cette section, nous explorerons comment lister les messages dans un dossier spécifique en utilisant le GraphClient et Aspose.Email pour .NET.

Une fois que vous avez le dossier, lister les messages qu’il contient est simple. Le GraphClient fournit une méthode ListMessages pour récupérer tous les messages dans un dossier, que vous pouvez ensuite traiter ou afficher.

Voici le code pour lister les messages du dossier spécifié :

Console.WriteLine("Liste des messages dans le dossier spécifié...");

// Appeler la méthode du client pour lister les messages dans le dossier sélectionné
var messageInfoCollection = client.ListMessages(targetFolder.ItemId);

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

// Imprimer les lignes de sujet des messages
foreach (var messageInfo in messageInfoCollection)
{
    Console.WriteLine($"     - {messageInfo.Subject}");
}

La collection messageInfoCollection contient des détails essentiels sur chaque e-mail. Ces informations peuvent être utilisées pour afficher des résumés, générer des rapports, ou même déclencher des alertes basées sur des critères spécifiques.

Conclusion

Dans cet article, nous avons exploré comment tirer parti de la puissance de Microsoft Graph et de la bibliothèque Aspose.Email pour .NET pour traiter efficacement les boîtes aux lettres, naviguer dans les hiérarchies de dossiers et lister les messages dans des dossiers spécifiques. En suivant ces étapes, vous pouvez créer des applications robustes qui interagissent sans effort avec les données de messagerie, offrant une fonctionnalité et une expérience utilisateur améliorées.

Concepts en action

Si vous êtes désireux de voir ces concepts en action, vous pouvez télécharger un exemple fonctionnel d’une application de travail. Cette application comprend le code source décrit dans cet article et démontre comment mettre en œuvre ces fonctionnalités étape par étape.

Visitez notre dépôt GitHub pour accéder à l’application d’exemple : Aspose.Email pour .NET - Exemple GraphApp.

Le traitement des boîtes aux lettres via Microsoft Graph offre un accès inégalé aux données de messagerie et aux capacités de gestion. Avec les bons outils et techniques, vous pouvez construire des applications sophistiquées qui fournissent des informations significatives et automatisent des tâches complexes, améliorant finalement la productivité et la satisfaction des utilisateurs.

Essayez-le gratuitement

De plus, Aspose.Email fournit une documentation complète, une référence API exhaustive et une variété d’outils et d’applications en ligne gratuites pour améliorer votre processus de développement. Les développeurs peuvent également accéder à un forum de support gratuit pour obtenir de l’aide et des informations de la communauté, et rester informés des dernières astuces et tutoriels via le blog d’Aspose.

Voir aussi