Verwalten Sie E‑Mail‑Nachrichten und Anhänge mit Microsoft Graph

Aspose.Email IGraphClient bietet eine breite Palette von Methoden zur Verwaltung von E-Mails und deren Anhängen über Microsoft Graph.

Verfügbare Vorgänge:

Nachrichten auflisten
Nachrichten filtern und paginieren
Nachrichteninhalt abrufen
Nachrichten erstellen und senden (einschließlich Entwürfen und EML)
Nachrichten kopieren und verschieben
Anhänge verwalten (erstellen, abrufen, löschen, auflisten)

Auflisten Nachrichten
Abrufen Nachricht
Erstellen Nachricht
Senden Nachricht
CopyMessage Nachricht
Verschieben Nachricht
CreateAttachment
FetchAttachment
DeleteAttachment
ListAttachments

Nachrichten auflisten

Um Nachrichten aus einem Ordner wie "Posteingang" abzurufen, verwenden Sie ListMessages Methode.

Abrufen der Ordnerliste mit client.ListFolders().
Durchlaufen Sie jeden Ordner.
Prüfen Sie, ob der Anzeigename des Ordners "Inbox" ist.
Falls ja, listen Sie die Nachrichten im Posteingang auf mit client.ListMessages(folder.ItemId).
Durchlaufen Sie jede Nachricht im Posteingang.
Geben Sie den Betreff jeder Nachricht in der Konsole aus.

var folders = client.ListFolders();

foreach (var folder in folders)
{
    if (folder.DisplayName.Equals("Inbox"))
    {
        // list messages in inbox
        var inboxMessages = client.ListMessages(folder.ItemId);

        foreach (var messageInfo in inboxMessages)
        {
            Console.WriteLine(messageInfo.Subject);
        }
    }
}

Nachrichten asynchron mit Microsoft Graph auflisten

Das folgende Codebeispiel zeigt, wie Sie den Posteingangs‑Ordner öffnen und eine Seite E‑Mail‑Nachrichten abrufen mit ListMessagesAsync, und geben Sie deren Betreff aus:

var folders = await client.ListFoldersAsync();
foreach (var folder in folders)
{
    Console.WriteLine(folder.DisplayName);
}

var folderId = folders.Find(x => x.DisplayName == "Inbox").ItemId;
var msgsPage = await client.ListMessagesAsync(folderId, new PageInfo(15) { PageOffset = 0 }, null);
var msgs = msgsPage.Items;
foreach (var msg in msgs)
{
    Console.WriteLine(msg.Subject);
}

Nachrichten nach Versanddatum filtern

Die OrderBy Methode aus der Bibliothekssammlung ermöglicht das Abrufen von Nachrichten mit verschiedenen Sortierreihenfolgen (auf‑ und absteigend) basierend auf dem Versanddatum. Das folgende Codebeispiel zeigt, wie Sie Nachrichten nach ihrem Versanddatum sortieren:

Initialisieren Sie den Graph‑Client
- Erstellen Sie eine Instanz von IGraphClient unter Verwendung von GraphClient.GetClient() mit dem Provider und TenantId.
Erstellen Sie einen Abfrage‑Builder
- Instanziieren Sie ein GraphQueryBuilder Objekt.
Nachrichten nach Datum ordnen in:

Absteigende Reihenfolge
- Verwenden builder.SentDate.OrderBy(false) um die Reihenfolge auf absteigend zu setzen.
- Rufen Sie client.ListMessages() um Nachrichten aus dem Posteingang mit einem Limit von 10 zu erhalten, unter Verwendung der Abfrage von builder.GetQuery().
- Speichern Sie die abgerufenen Nachrichten in der Variable messages.
Aufsteigende Reihenfolge
- Stellen Sie die Reihenfolge auf aufsteigend ein, indem Sie aufrufen builder.SentDate.OrderBy(true).
- Verwenden client.ListMessages() erneut, um Nachrichten aus dem Posteingang abzurufen, jetzt in aufsteigender Reihenfolge.
- Speichern Sie diese Nachrichten in der Variable messages.

IGraphClient client = GraphClient.GetClient(provider, TenantId);

var builder = new GraphQueryBuilder();

// create orderby messages query 'DESC'
builder.SentDate.OrderBy(false);
var messagePageInfo = client.ListMessages(KnownFolders.Inbox, new PageInfo(10), builder.GetQuery());
var messages = messagePageInfo.Items;

builder.Clear();

// create orderby messages query 'ASC'
builder.SentDate.OrderBy(true);
messagePageInfo = client.ListMessages(KnownFolders.Inbox, new PageInfo(10), builder.GetQuery());
messages = messagePageInfo.Items;

Nachrichten mit Paginierung und Filterung auflisten

Verwenden Sie Paginierung bei großen Postfächern. Das folgende Beispiel ruft ungelesene Nachrichten in Seiten zu je 10 ab und markiert sie nach der Verarbeitung als gelesen:

Initialisieren Sie den Client.
Legen Sie die Anzahl der pro Seite anzuzeigenden Elemente fest, z. B. 10.
Erstellen Sie einen Filter, um nur ungelesene Nachrichten abzurufen, indem Sie die GraphQueryBuilder Klasse. Die builder.IsRead.Equals(false) setzt die Bedingung zum Filtern ungelesener Nachrichten.
Rufen Sie die ListMessages Methode am Client‑Objekt, wobei der Ordner (Inbox) und die Elemente pro Seite (PageInfo(itemsPerPage)) als Parameter angegeben werden. Sie übergibt außerdem das Abfrageobjekt, um den Filter für ungelesene Nachrichten anzuwenden. Das zurückgegebene PageInfo‑Objekt (pageInfo) enthält die abgerufenen Nachrichten für die aktuelle Seite in der Eigenschaft Items.
Erstellen Sie eine Schleife, die fortsetzt, bis die letzte Seite erreicht ist (pageInfo.LastPage ist false). Die abgerufenen Nachrichten werden der bestehenden Nachrichtenliste hinzugefügt mit messages.AddRange(pageInfo.Items).

//  reading unread messages with paging
using var client = GraphClient.GetClient(tokenProvider, config.Tenant);

// paging option
var itemsPerPage = 10;
// create unread messages filter
GraphQueryBuilder builder = new GraphQueryBuilder();
builder.IsRead.Equals(false);
var query = builder.GetQuery();

// list messages
var pageInfo = client.ListMessages(KnownFolders.Inbox, new PageInfo(itemsPerPage), query);
var  messages = pageInfo.Items;

while (!pageInfo.LastPage)
{
    pageInfo = client.ListMessages(KnownFolders.Inbox, pageInfo.NextPage, query);
    messages.AddRange(pageInfo.Items);
}

// set messages state as read
foreach (var message in messages)
{
    client.SetRead(message.ItemId);
}

Nachricht abrufen

Rufen Sie den vollständigen Inhalt einer bestimmten Nachricht ab. Das folgende Codebeispiel zeigt, wie Sie die neuste Nachricht im Posteingang abrufen und anzeigen können, zum Anzeigen oder zur Verarbeitung:

Rufen Sie client.ListFolders() um alle verfügbaren Ordner im Postfach abzurufen und sie in der Variable folders zu speichern.
Durchlaufen Sie jeden Ordner in der Ordnersammlung mit einer foreach‑Schleife.
Innerhalb der Schleife prüfen, ob der Ordnername "Inbox" lautet.
Falls der Ordner der Posteingang ist, rufen Sie die Nachrichten ab mit client.ListMessages() mit der Ordner‑ItemId.
Überprüfen Sie, ob Nachrichten im Posteingang vorhanden sind, indem Sie prüfen, ob inboxMessages.Count größer als 0 ist.
Falls Nachrichten vorhanden sind, rufen Sie die erste Nachricht ab mit client.FetchMessage() mit der ItemId der ersten Nachricht.
Geben Sie den HTML‑Body der abgerufenen Nachricht aus.

var folders = client.ListFolders();

foreach (var folder in folders)
{
    if (folder.DisplayName.Equals("Inbox"))
    {
        // list messages in inbox
        var inboxMessages = client.ListMessages(folder.ItemId);

        if (inboxMessages.Count > 0)
        {
            // fetch the first message in inbox
            var msg = client.FetchMessage(inboxMessages[0].ItemId);
            
            Console.WriteLine(msg.BodyHtml);
        }
        
    }
}

Microsoft Graph‑Abfragen mit OData

Aspose.Email für .NET bietet OData‑Abfrageunterstützung für Microsoft Graph. Dies ermöglicht Entwicklern, erweiterte Filterungen, Sortierungen, Auswahlen, Paginierung und Expansionen bei der Arbeit mit Graph‑Ressourcen wie Ordnern, Nachrichten, Kontakten, Kalender‑Einträgen und mehr anzuwenden. Das Aspose.Email.Clients.Graph.ODataQueryBuilder Klasse wurde entwickelt, um OData‑Abfrageparameter strukturiert zu erstellen, anstatt Abfrage‑Strings manuell zu bauen. So können Sie nur notwendige Felder abrufen (Select) für Effizienz, Filtern verwenden (Filter) und Sortierung (OrderBy) um Daten zu organisieren. Sie können auch Paginierung implementieren (Top, Skip) für große Datensätze, verwandte Entitäten erweitern (Expand) in einem Aufruf, und ermöglichen Zählung sowie Volltextsuche für erweiterte Szenarien.

Nachfolgend die Liste der GraphClient Methoden, die ein optionales ** unterstützenODataQueryBuilder** Parameter:

ListFolders
ListMessages
ListContacts
ListCalendarItems
ListAttachments
ListCategories
ListOverrides
ListRules
ListTaskLists
ListTasks
ListNotebooks

Das folgende Codebeispiel demonstriert die Verwendung von ODataQueryBuilder um Ordner aufzulisten und gefilterte, sortierte sowie paginierte E‑Mail‑Nachrichten aus einem Postfach abzurufen:**

var accessParameters = Settings.User1;

var provider = new AzureConfidentialTokenProvider(
    accessParameters.TenantId,
    accessParameters.ClientId,
    accessParameters.ClientSecret);

var client = GraphClient.GetClient(provider, accessParameters.TenantId);

client.Resource = Aspose.Email.Clients.Graph.ResourceType.Users;
client.ResourceId = accessParameters.Username;
client.EndPoint = "https://graph.microsoft.com";

// Example 1: List folders ordered by name
var builder = new ODataQueryBuilder { OrderBy = "name asc" };
var folders = client.ListFolders(builder);

foreach (var folder in folders)
{
    Console.WriteLine(folder.DisplayName);
}

// Example 2: Retrieve filtered and paged messages from Inbox
var folderId = folders.Find(x => x.DisplayName == "Inbox").ItemId;

builder = new ODataQueryBuilder
{
    Filter = "startswith(name,'A')",
    OrderBy = "name asc",
    Top = 10,
    Skip = 5,
    Select = new[] { "name", "age" },
    Expand = new[] { "children", "parents" },
    Count = true,
    Search = "\"John Doe\"",
    Format = "json"
};

var msgs = client.ListMessages(folderId, builder);

foreach (var msg in msgs)
{
    Console.WriteLine(msg.Subject);
}

Nachricht erstellen

Verwenden Sie die CreateMessage Methode, um eine neue Nachricht direkt in einen bestimmten Ordner, z. B. den Posteingang, zu speichern. Das folgende Beispiel zeigt, wie man ein MapiMessage und fügt sie dem Postfach hinzu.

var msg = new MapiMessage(OutlookMessageFormat.Unicode)
{
    Subject = "My message",
    Body = "Hi, it is my message"
};

msg.Recipients.Add("sam@to.com", "Sam", MapiRecipientType.MAPI_TO);

// create message in inbox
client.CreateMessage(KnownFolders.Inbox, msg);

Nachrichten senden

Die Senden Methode von IGraphClient ermöglicht das direkte Senden einer E‑Mail‑Nachricht mithilfe eines MapiMessage Objekt. In diesem Beispiel wird eine einfache Nachricht erstellt, mit Absender- und Empfängerdetails konfiguriert und dann gesendet.

// prepare the message
var msg = new MapiMessage(OutlookMessageFormat.Unicode)
{
    Subject = "My message",
    Body = "Hi, it is my message"
};

msg.Recipients.Add("sam@to.com", "Sam", MapiRecipientType.MAPI_TO);
msg.SetProperty(KnownPropertyList.SenderName, "John");
msg.SetProperty(KnownPropertyList.SentRepresentingEmailAddress, "John@from.com");

// send message
client.Send(msg);

Senden Sie eine Entwurfsnachricht

Sie können eine Nachricht im Entwurfsordner speichern und später senden mit IGraphClient. Dieser Ansatz ermöglicht es Ihnen, eine Nachricht vorzubereiten, zu prüfen oder zu ändern, bevor sie gesendet wird, und sie dann zu versenden, wenn sie bereit ist. Das folgende Codebeispiel zeigt, wie Sie eine E‑Mail erstellen, Metadaten hinzufügen, sie als Entwurf speichern und anschließend senden:

Erstellen Sie ein MapiMessage mit Betreff, Inhalt und Empfängern.
Setzen Sie die Absenderdetails über Nachrichteneigenschaften.
Speichern Sie die Nachricht im Entwurfsordner mit CreateMessage.
Senden Sie den Entwurf, indem Sie seine ItemId an die Send() Methode.

// prepare the message
var msg = new MapiMessage(OutlookMessageFormat.Unicode)
{
    Subject = "My message",
    Body = "Hi, it is my message"
};

msg.Recipients.Add("sam@to.com", "Sam", MapiRecipientType.MAPI_TO);
msg.SetProperty(KnownPropertyList.SenderName, "John");
msg.SetProperty(KnownPropertyList.SentRepresentingEmailAddress, "John@from.com");

// add message to Draft folder
var draftMessage = client.CreateMessage(KnownFolders.Drafts, msg);

// send a draft message
client.Send(draftMessage.ItemId);

Senden Sie eine EML‑Nachricht

Verwenden Sie die MailMessage Klasse, um EML‑formatierte Nachrichten zu erstellen und zu senden. Das folgende Codebeispiel zeigt, wie man eine E‑Mail‑Nachricht mit der Graph‑API erstellt und sendet:

// prepare the message
var eml = new MailMessage
{
    From = "from@domain.com",
    To = "to1@domain.com, to2@domain.com",
    Subject = "New message",
    HtmlBody = "<html><body>This is the HTML body</body></html>"
};

// send the message
graphClient.Send(eml);
graphClient.Create(KnownFolders.Inbox, eml);

Nachrichten kopieren

Um eine Kopie einer bestehenden E‑Mail‑Nachricht zu erstellen, verwenden Sie die CopyMessage Methode des IGraphClient Interface.


// copy message to Inbox folder
var copiedMsg = client.CopyMessage(KnownFolders.Inbox, msg.ItemId);

Nachrichten verschieben

Um eine vorhandene E‑Mail‑Nachricht von ihrem aktuellen Speicherort in einen neuen Ordner zu verschieben, verwenden Sie die MoveMessage Methode des IGraphClient Interface.

// move message to Inbox folder
var movedMsg = client.MoveMessage(KnownFolders.Inbox, msg.ItemId);

Anhänge verwalten

Die IGraphClient in Aspose.Email für .NET ermöglicht es Ihnen, programmgesteuert mit E‑Mail‑Anhängen zu arbeiten. Dazu gehören das Erstellen, Abrufen, Löschen und Auflisten von Anhängen, die einer Nachricht zugeordnet sind. Das folgende Codebeispiel demonstriert die vollständige Verwaltung des Anhangslebenszyklus für Outlook‑Nachrichten über die Microsoft Graph‑API mit Aspose.Email. Sie können den Anhangsinhalt und die Metadaten nach Bedarf anpassen.


// create an attachment
var attachment = new MapiAttachment();
attachment.SetProperty(KnownPropertyList.DisplayName, "My Attachment");
attachment.SetProperty(KnownPropertyList.AttachDataBinary, new byte[1024]);

// add an attachment to message
var createdAttachment = client.CreateAttachment(messageInfo.ItemId, attachment);

// fetch a message attachment
var fetchedAttachment = client.FetchAttachment(createdAttachment.ItemId);

// delete a message attachment 
client.DeleteAttachment(createdAttachment.ItemId);

// list the message attachments
var attachments = client.ListAttachments(messageInfo.ItemId);

Verwalten von Mail‑Ordnern in Microsoft Graph (Aspose.Email) Verwalten von Outlook‑Elementen über den Aspose.Email Graph‑Client