Microsoft Graph zur Verwaltung von Mailboxen in C#

Die Integration der Microsoft Graph API und der Aspose.Email für .NET-Bibliothek mit einer E-Mail-Anwendung ermöglicht es Entwicklern, Mailbox-Daten einfach zuzugreifen und zu manipulieren, Operationen wie das Abrufen von Nachrichten, das Abrufen von Ordnerhierarchien und das Speichern von E-Mails in verschiedenen Formaten durchzuführen. In diesem Artikel werden wir erkunden, wie man diese leistungsstarke Kombination zur Verarbeitung und Verwaltung von Mailboxen nutzt.

Microsoft Graph-Präsentation

Microsoft Graph ist eine umfassende API-Plattform, die von Microsoft bereitgestellt wird und einen einheitlichen Endpunkt bietet, um auf eine Vielzahl von Microsoft-Diensten und -Daten zuzugreifen. Es dient als Gateway zu den umfangreichen Daten, die in Microsoft 365 verfügbar sind, einschließlich Outlook-Mailboxen, Kalendern, Kontakten, OneDrive, Teams und mehr.

Mit Microsoft Graph können Entwickler Anwendungen erstellen, die nahtlos mit Benutzerdaten und Einblicken im Microsoft-Cloud-Ökosystem interagieren. Dies wird durch RESTful APIs und SDKs erreicht, die die Mittel bereitstellen, um Daten einfach zu authentifizieren, zu autorisieren und abzufragen.

Über die Aspose.Email für .NET-Bibliothek

Aspose.Email für .NET ist eine funktionsreiche Bibliothek, die Entwicklern ermöglicht, mit E-Mail-Dateien und -Protokollen in ihren .NET-Anwendungen zu arbeiten. Sie bietet eine robuste Sammlung von APIs zum Erstellen, Manipulieren und Konvertieren von E-Mail-Nachrichten in verschiedenen Formaten wie MSG, EML und MBOX. Darüber hinaus unterstützt die Bibliothek E-Mail-Protokolle wie SMTP, POP3 und IMAP, die eine vielseitige E-Mail-Verwaltung ermöglichen.

In diesem Leitfaden werden wir Aspose.Email verwenden, um mit Microsoft Graph zu interagieren und Mailbox-Daten programmgesteuert zu verarbeiten. Mit dem GraphClient von Aspose.Email können wir Mailbox-Operationen effizient durchführen, indem wir uns bei Microsoft Graph authentifizieren.

Um die Bibliothek zu nutzen, müssen Sie sie in Ihr Projekt integrieren. Der einfachste Weg, Aspose.Email für .NET zu erhalten, ist über den NuGet-Paket-Manager:

  • Öffnen Sie Ihr Projekt in Visual Studio.
  • Navigieren Sie zu Tools > NuGet-Paket-Manager > NuGet-Pakete für die Lösung verwalten.
  • Suchen Sie nach Aspose.Email.
  • Wählen Sie das Paket aus und klicken Sie auf Installieren.

Alternativ können Sie die Paket-Manager-Konsole verwenden:

Install-Package Aspose.Email

Sie können auch die neueste Version der API direkt von der Aspose Website herunterladen.

Konfigurieren Sie Ihre App im Azure-Portal

Bevor wir in den Code eintauchen, ist es wichtig, Ihre Anwendung im Azure-Portal zu konfigurieren, um den Zugriff auf Microsoft Graph zu ermöglichen. Befolgen Sie einfach diese Schritte:

  1. Erstellen Sie eine Azure Active Directory (AAD) Anwendung:

    • Navigieren Sie zum Azure-Portal.
    • Gehen Sie zu Azure Active Directory > App-Registrierungen.
    • Klicken Sie auf Neue Registrierung, um eine neue Anwendung zu erstellen.
    • Geben Sie einen Namen ein und setzen Sie die Umleitungs-URI, falls erforderlich.
    • Klicken Sie auf Registrieren, um den Vorgang abzuschließen.

  2. API-Berechtigungen festlegen:

    • Navigieren Sie in Ihrer registrierten App zu API-Berechtigungen.
    • Klicken Sie auf Berechtigung hinzufügen > Microsoft Graph.
    • Wählen Sie Anwendungsberechtigungen für serverseitige Aufrufe aus.
    • Wählen Sie erforderliche Berechtigungen wie Mail.Read, Mail.ReadWrite, User.Read usw.
    • Klicken Sie auf Berechtigungen hinzufügen, um sie anzuwenden.

  3. Erstellen Sie ein Client-Geheimnis:

    • Gehen Sie zu Zertifikate & Geheimnisse in Ihrer App.
    • Klicken Sie auf Neues Client-Geheimnis und geben Sie eine Beschreibung ein.
    • Legen Sie einen Zeitraum für die Ablaufdauer fest und klicken Sie dann auf Hinzufügen.
    • Notieren Sie sich den generierten Wert für das Client-Geheimnis, da Sie ihn später benötigen werden.

  4. Sammeln Sie Konfigurationswerte:

    • Erhalten Sie die Mandanten-ID, Client-ID und Client-Geheimnis von der Übersichtsseite Ihrer App und dem Abschnitt Geheimnisse.
    • Sie verwenden diese Werte, um sich zu authentifizieren und mit Microsoft Graph zu interagieren.

Sobald Ihre Anwendung konfiguriert ist, sind Sie bereit, mit den Entwicklungsaufgaben fortzufahren.

Zugriffstoken abrufen und GraphClient initialisieren

Bevor wir uns mit Mailbox-Operationen befassen, müssen wir die Tür zum umfangreichen Ökosystem von Daten und Diensten von Microsoft Graph öffnen. Dieser Zugriff wird durch ein OAuth 2.0-Zugriffstoken gewährt - einen digitalen Schlüssel, der Ihrer Anwendung die Interaktion mit Microsoft Graph im Namen eines Benutzers oder Dienstes autorisiert. Stellen Sie sich das als einen sicheren Pass vor, der Ihnen Zugang zu einem gesamten Universum von Möglichkeiten gewährt, von E-Mails abrufen bis Kontakte verwalten und mehr.

Schritt 1: Eine Konfigurationsdatei einrichten

Der erste Schritt zum Erwerben des Tokens besteht darin, eine Konfigurationsdatei einzurichten, die wesentliche Details wie die Mandanten-ID, Client-ID und Client-Geheimnis Ihrer Anwendung speichert. Diese Werte sind die Anmeldeinformationen Ihrer Anwendung und fungieren als Identifikatoren bei der Kommunikation mit Microsoft-Servern.

Hier ist, wie Ihre JSON-Konfiguration aussehen könnte:

{
    "Instance": "https://login.microsoftonline.com/{0}",
    "ApiUrl": "https://graph.microsoft.com/.default",
    "TenantId": "IHRE_TENANT_ID_HIER",
    "ClientId": "IHRE_APP_ID_HIER",
    "ClientSecret": "IHRE_CLIENT_SECRET_HIER",
    "UserId": "IHRE_ID_HIER"
}

Schritt 2: JSON-Konfiguration auf ein C#-Objekt abbilden

Jetzt lassen Sie uns diese Konfiguration in ein C#-Objekt umwandeln, das unsere Anwendung verwenden kann. Wir werden die JSON-Datei lesen und deren Inhalte auf eine AuthenticationConfig-Klasse abbilden, um sicherzustellen, dass unsere Anwendung weiß, wo sie die benötigten kritischen Informationen finden kann.

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

Schritt 3: Zugriffstoken erwerben

Mit unserer Konfiguration in Place ist es Zeit, das Zugriffstoken zu erwerben. Wir implementieren eine GraphTokenProvider-Klasse, die den Authentifizierungsprozess mithilfe der Microsoft Authentication Library (MSAL) verwaltet. Diese Klasse kümmert sich um die schwere Arbeit - die Kommunikation mit Microsoft Graph, um das Token zu erhalten, das unsere Anwendung befähigt.

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

        // In Memory Token Caches (App und User Caches)
        _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($"Das Token wurde von {result.AuthenticationResultMetadata.TokenSource} {Environment.NewLine}erworben");
        }
        catch (MsalServiceException ex)
        {
            Console.WriteLine($"Fehler beim Erwerb des Tokens: {Environment.NewLine}{ex}{Environment.NewLine}");
            result = null;
        }

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

Schritt 4: GraphClient initialisieren

Schließlich initialisieren wir den GraphClient mit dem Token, das wir erworben haben. Der GraphClient fungiert als unsere Brücke zu Microsoft Graph und ermöglicht es uns, nahtlos mit Benutzer-Mailboxen zu interagieren.

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;

Ordnerhierarchie abrufen und Ordner nach Namen abrufen

Nachdem Sie Zugriff auf Microsoft Graph erhalten haben, ist es an der Zeit, die Mailbox zu erkunden. In diesem Abschnitt werden wir uns mit dem Abrufen und Navigieren der Ordnerhierarchie einer Mailbox befassen, damit Sie auf bestimmte Ordner nach Namen zugreifen können.

Schritt 1: Verstehen der Ordnerhierarchie

Mailboxes sind hierarchisch strukturiert, ähnlich wie ein Baum. Der Stammordner verzweigt sich in mehrere Unterordner, die jeweils ihre eigenen E-Mails und möglicherweise weitere Unterordner enthalten. Diese verschachtelte Struktur ermöglicht eine organisierte Verwaltung und eine einfache Navigation durch E-Mails.

Lassen Sie uns die FolderNode-Klasse definieren und verwenden, um jeden Ordner in der Hierarchie darzustellen:

// Stellt einen Knoten in einer Ordnerhierarchie dar,
// erweitert die Eigenschaften von FolderInfo und speichert eine Sammlung von Unterordnern.
class FolderNode
{
    // Gibt das FolderInfo-Objekt zurück, das die Ordnerinformationen darstellt.
    public FolderInfo Folder { get; }
    
    // Gibt die Sammlung von Unterordnern zurück, die im aktuellen Ordner enthalten sind.
    public List<FolderNode?> SubFolders { get; }

    // Initialisiert eine neue Instanz der FolderNode-Klasse mit dem angegebenen FolderInfo-Objekt.
    public FolderNode(FolderInfo folder)
    {
        Folder = folder;
        SubFolders = new List<FolderNode?>();
    }
    
    // Gibt alle Ordner in einer hierarchischen Weise aus, beginnend vom aktuellen Knoten.
    public void PrintHierarchy()
    {
        PrintFolderNode(this, 0);
    }

    private void PrintFolderNode(FolderNode node, int indentLevel)
    {
        // Gibt den aktuellen Ordnerknoten mit Einrückung aus
        Console.WriteLine($"{new string(' ', indentLevel * 2)}{node}");

        // Gibt rekursiv Unterordner aus
        foreach (var subFolder in node.SubFolders)
        {
            PrintFolderNode(subFolder, indentLevel + 1);
        }
    }

    // Gibt den Anzeigenamen des Ordners zurück.
    public override string ToString()
    {
        return $"{Folder.DisplayName} ({Folder.ContentCount})";
    }
}

Um die gesamte Ordnerhierarchie abzurufen, erstellen wir die FolderHierarchy-Klasse, die den GraphClient verwendet, um alle Ordner rekursiv aufzulisten. So funktioniert es:

static class FolderHierarchy
{
    // Ruft alle Ordner in der Mailbox rekursiv ab und gibt eine hierarchische Sammlung von FolderNode-Objekten zurück.
    public static List<FolderNode> Retrieve(IGraphClient client)
    {
        // Ruft Stammordner ab
        var rootFolders = client.ListFolders();
        var allFolders = new List<FolderNode>();

        // Ruft Unterordner rekursiv ab
        foreach (var folder in rootFolders)
        {
            var folderNode = new FolderNode(folder);
            RetrieveSubFolders(client, folderNode);
            allFolders.Add(folderNode);
        }

        return allFolders;
    }

    // Ruft Unterordner rekursiv ab und fügt sie der SubFolders-Eigenschaft des übergeordneten FolderNode hinzu.
    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);
            }
        }
    }
}

Schritt 2: Die Ordnerhierarchie abrufen

Mit der Methode FolderHierarchy.Retrieve können Sie mühelos die Mailbox durchqueren, um ihre Ordnerstruktur zu entdecken. So können Sie dies erreichen:

// Ruft die Ordnerhierarchie aus der Mailbox ab
var folderNodes = FolderHierarchy.Retrieve(client);

// Gibt die Ordnerhierarchie in strukturierter Form aus
foreach (var folderNode in folderNodes)
{
    folderNode.PrintHierarchy();
}

Schritt 3: Ordner nach Namen abrufen

Sobald die Ordnerhierarchie abgerufen wurde, können Sie spezifische Ordner nach Namen identifizieren. Egal, ob Sie auf den Posteingang oder einen benutzerdefinierten Ordner zugreifen möchten, diese Methode stellt sicher, dass Sie sie schnell finden können:

// Geben Sie den Ordnernamen an, den Sie suchen
string targetFolderName = "Posteingang";

// Finden Sie den Zielordner nach Namen
var targetFolder = folderNodes.FirstOrDefault(
    folderNode => folderNode.Folder.DisplayName.Equals(targetFolderName, StringComparison.OrdinalIgnoreCase))
    ?.Folder;

Nachrichten im angegebenen Ordner auflisten

Nachdem die Ordnerhierarchie erfolgreich abgerufen wurde, besteht der nächste Schritt darin, den Inhalt spezifischer Ordner zu durchsuchen. Stellen Sie sich vor, Sie haben Ihren Posteingang erreicht; jetzt möchten Sie alle Nachrichten anzeigen, die er enthält.

In diesem Abschnitt werden wir erkunden, wie man Nachrichten innerhalb eines bestimmten Ordners auflistet, indem man den GraphClient und Aspose.Email für .NET verwendet.

Sobald Sie den Ordner haben, ist das Auflisten der Nachrichten darin einfach. Der GraphClient bietet eine Methode ListMessages, um alle Nachrichten in einem Ordner abzurufen, die Sie dann verarbeiten oder anzeigen können.

Hier ist der Code, um Nachrichten aus dem angegebenen Ordner aufzulisten:

Console.WriteLine("Auflisten von Nachrichten im angegebenen Ordner...");

// Rufen Sie die Clientmethode auf, um Nachrichten im ausgewählten Ordner aufzulisten
var messageInfoCollection = client.ListMessages(targetFolder.ItemId);

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

// Geben Sie die Betreffzeilen der Nachrichten aus
foreach (var messageInfo in messageInfoCollection)
{
    Console.WriteLine($"     - {messageInfo.Subject}");
}

Die messageInfoCollection enthält wichtige Details zu jeder E-Mail. Diese Informationen können verwendet werden, um Zusammenfassungen anzuzeigen, Berichte zu erstellen oder sogar Benachrichtigungen basierend auf bestimmten Kriterien auszulösen.

Fazit

In diesem Artikel haben wir erkundet, wie man die Macht von Microsoft Graph und der Aspose.Email für .NET-Bibliothek nutzt, um Mailboxen effektiv zu verarbeiten, Ordnerhierarchien zu navigieren und Nachrichten innerhalb spezifischer Ordner aufzulisten. Indem Sie diese Schritte befolgen, können Sie robuste Anwendungen erstellen, die nahtlos mit E-Mail-Daten interagieren und erweiterte Funktionalität und Benutzererlebnisse bieten.

Konzepte in Aktion

Wenn Sie diese Konzepte in Aktion sehen möchten, können Sie ein voll funktionsfähiges Beispiel einer funktionierenden Anwendung herunterladen. Diese Anwendung enthält den Quellcode, der in diesem Artikel beschrieben ist, und zeigt, wie man diese Funktionen Schritt für Schritt implementiert.

Besuchen Sie unser GitHub-Repository, um auf die Beispielanwendung zuzugreifen: Aspose.Email für .NET - GraphApp-Beispiel.

Die Verarbeitung von Mailboxen über Microsoft Graph bietet unvergleichlichen Zugriff auf E-Mail-Daten und Verwaltungsmöglichkeiten. Mit den richtigen Werkzeugen und Techniken können Sie anspruchsvolle Anwendungen entwickeln, die bedeutende Einblicke bieten und komplexe Aufgaben automatisieren, was die Produktivität und die Zufriedenheit der Benutzer letztendlich steigert.

Testen Sie es kostenlos

Darüber hinaus bietet Aspose.Email umfassende Dokumentationen, eine umfangreiche API-Referenz und eine Vielzahl von kostenlosen Online-Tools und Apps, um Ihren Entwicklungsprozess zu verbessern. Entwickler können auch auf ein kostenloses Support-Forum für Community-Hilfe und -Einblicke zugreifen und bleiben über die neuesten Tipps und Tutorials über den Aspose Blog informiert.

Siehe auch