Microsoft‑365‑Datenzugriff und -verwaltung mit Microsoft Graph

Optimieren Sie den Zugriff und die Verwaltung von Microsoft 365‑Daten mit dem Aspose.Email Graph‑Client

Microsoft Graph ist eine REST‑API zum Zugriff auf Microsoft‑365‑Daten. Die Implementierung des Graph‑Clients in Aspose.Email für .NET ermöglicht den Zugriff auf Microsoft Graph über unsere API. In den nachfolgenden Beispielen erstellen wir eine Instanz des MS Graph‑Clients und übergeben das Token. Anschließend untersuchen wir die wichtigsten Methoden zum Verwalten von Ordnern, zum Aktualisieren, Kopieren und Löschen. Nachrichten, deren Inhalt und Anhänge können ebenfalls mit unserem MS Graph‑Client abgerufen oder geändert werden. Die Verwaltung von Kategorien, Regeln, Notizbüchern und Overrides ist eine erweiterte Funktion des Microsoft Graph‑Clients von Aspose.Email.

Authentifizieren und Anfragen mit IGraphClient unter Verwendung von MSAL in .NET

Um mit Microsoft Graph-Diensten zu interagieren, müssen Sie ein IGraphClient Objekt. Sobald authentifiziert, ermöglicht dieser Client Ihnen, verschiedene Dienstanfragen zu stellen. Das GetClient Methode, die das IGraphClient, erfordert ein ITokenProvider Implementierung als ersten Parameter. Dies ITokenProvider ist verantwortlich für die Bereitstellung des erforderlichen Authentifizierungstokens. Um das Token zu erhalten, verwenden wir die Microsoft Authentication Library (MSAL) für .NET.

So richten Sie den Authentifizierungsprozess ein:

Schritt 1: Einrichtung der Authentifizierung

Die folgenden Schritte führen Sie dabei, ein Autorisierungstoken zu erhalten:

  1. Erstellen Sie die AccessParameters-Klasse.

    Definieren Sie eine AccessParameters-Klasse, um Ihre Anmeldeinformationen zu speichern.

public class AccessParameters
{
    public string TenantId { get; init; }
    public string ClientId { get; init; }
    public string ClientSecret { get; init; }
    public string UserId { get; init; }
    public Uri Authority => new ($"https://login.microsoftonline.com/{TenantId}");
    public string ApiUrl => "https://graph.microsoft.com/.default";
}

  1. Fügen Sie das hinzu MSAL.NET-Paket.

    Installieren Sie das Microsoft.Identity.Client NuGet-Paket, das die für die Authentifizierung erforderlichen MSAL.NET-Binärdateien enthält.

  2. Implementieren Sie das ITokenProvider-Interface.

    Erstellen Sie ein GraphTokenProvider Klasse, die das implementiert ITokenProvider Schnittstelle. Diese Klasse verwendet die MSAL.NET-Bibliothek, um ein Zugriffstoken zu erhalten.

using Microsoft.Identity.Client;
using Microsoft.Identity.Web;
using Aspose.Email.Clients;

public class GraphTokenProvider : ITokenProvider
{
    private readonly IConfidentialClientApplication _app;
    private readonly string[] _scopes;
    private string? _token;

    public GraphTokenProvider(AccessParameters accessParams)
    {
        _app = ConfidentialClientApplicationBuilder.Create(accessParams.ClientId)
            .WithClientSecret(accessParams.ClientSecret)
            .WithAuthority(accessParams.Authority)
            .Build();

        _app.AddInMemoryTokenCache();

        _scopes = new[] { accessParams.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("Token acquired");
        }
        catch (MsalServiceException ex) when (ex.Message.Contains("AADSTS70011"))
        {
            Console.WriteLine("Scope provided is not supported");
            result = null;
        }

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

Schritt 2: Eine ITokenProvider‑Instanz erstellen

Nach der Definition der GraphTokenProvider Klasse zu instanziieren; Sie können eine Instanz von AccessParameters und verwenden Sie es, um die GraphTokenProvider.

var accessParams = new AccessParameters()
{
    TenantId = "Your Tenant ID",
    ClientId = "Your Client ID",
    ClientSecret = "Your Client Secret",
    UserId = "User's Object ID"
};

var tokenProvider = new GraphTokenProvider(accessParams);

Schritt 3: Anfragen mit IGraphClient stellen

Verwenden Sie abschließend das GraphTokenProvider um ein authentifiziertes IGraphClient und beginnen Sie mit Service‑Anfragen.

using var client = GraphClient.GetClient(tokenProvider, accessParams.TenantId);

client.Resource = ResourceType.Users;
client.ResourceId = accessParams.UserId;

Nachdem diese Schritte abgeschlossen sind, Ihre IGraphClient ist nun bereit, mit Microsoft‑Graph‑Diensten mittels authentifizierter Anfragen zu interagieren.

Verbindung zu GCC‑High‑Endpoints

Die GraphClient unterstützt die Verbindung zu GCC‑High‑Endpoints, indem es das EndPoint Eigenschaft. Das folgende Codebeispiel zeigt, wie Sie den GraphClient konfigurieren, um sich mit dem GCC‑High‑Endpunkt zu verbinden, um Ordner aufzulisten und Nachrichten abzurufen.

client.EndPoint = "https://graph.microsoft.us";

var folders = client.ListFolders();
string folderId = folders.Find(x => x.DisplayName == "Inbox").ItemId;
var msgs = client.ListMessages(folderId);

Ordner mit IGraphClient verwalten

List Folders

Durch Aufruf von ListFolders Methode vom MS Graph Client, mit der Sie die Ordnerliste abrufen können. Jeder Ordner verfügt über Parameter wie DisplayName, die gelesen werden können in FolderInfo Typ.

var folders = client.ListFolders();

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

Ordner aktualisieren

Um einen Ordner mit MS Graph Client zu erstellen, verwenden Sie CreateFolder Methode. Sie erhalten ein FolderInfo Objekt und die Möglichkeit, auf DisplayName, ItemId, HasSubFolders und andere Eigenschaften zuzugreifen.

var folderInfo = client.CreateFolder("FolderName");
folderInfo.DisplayName = "FolderAnotherName";
client.UpdateFolder(folderInfo);

Ordner kopieren

CopyFolder Methode ist die Schlüssel­methode zum Kopieren des Ordnerobjekts mit MS Graph.

var folderInfo1 = client.CreateFolder("Folder1");
var folderInfo2 = client.CreateFolder("Folder2");
    
// copy Folder2 to Folder1
client.CopyFolder(folderInfo1.ItemId, folderInfo2.ItemId);

Ordner verschieben und löschen

Verwenden MoveFolder Methode wird verwendet, um den Ordner zu verschieben; sie akzeptiert newParentId und itemId. Delete Methode wird verwendet, um eine Methode anhand ihrer ID zu löschen.

var folderInfo1 = client.CreateFolder("Folder1");
var folderInfo2 = client.CreateFolder("Folder2");
    
// move Folder2 to Folder1
client.MoveFolder(folderInfo1.ItemId, folderInfo2.ItemId);
    
// delete Folder1
client.Delete(folderInfo1.ItemId)

Nachrichten mit IGraphClient verwalten

MS Graph Client, implementiert in Aspose.Email für .NET, bietet eine Reihe von Methoden zur Verwaltung von Nachrichten und Anhängen:

Nachrichten auflisten

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 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:

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 Paging‑Unterstützung aufzählen

Die API ermöglicht das Paginieren und Filtern der Nachrichten beim Auflisten. Dies ist besonders nützlich für Postfächer mit hohem Nachrichtenvolumen, da nur die notwendigen Zusammenfassungsinformationen abgerufen werden.

Das Codebeispiel und die nachstehenden Schritte zeigen, wie Sie Nachrichten aus dem Ordner Inbox mithilfe von Paging‑ und Filterfunktionen abrufen.

  1. Zuerst initialisieren Sie den Client.
  2. Legen Sie dann die Anzahl der pro Seite anzuzeigenden Elemente fest, zum Beispiel 10.
  3. Erstellen Sie einen Filter, um nur ungelesene Nachrichten abzurufen, indem Sie die GraphQueryBuilder Klasse. builder.IsRead.Equals(false) setzt die Bedingung zum Filtern ungelesener Nachrichten.
  4. 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.
  5. Erstellen Sie eine Schleife, die fortgesetzt wird, bis die letzte Seite erreicht ist (pageInfo.LastPage ist false). Die abgerufenen Nachrichten werden der vorhandenen Nachrichtenliste mit messages.AddRange(pageInfo.Items) hinzugefügt.
//  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);
}

Nachrichten abrufen

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

Nachrichten erstellen

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

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

Entwurfsnachrichten senden

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

EML‑Nachrichten senden

Erstellen und Senden von E‑Mails ist einfach mit dem MailMessage‑Objekt. Das folgende Codebeispiel zeigt, wie Sie eine E‑Mail‑Nachricht mit der Graph‑API erstellen und senden:

// 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


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

Nachrichten verschieben

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

Anhänge verwalten


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

Outlook‑Elemente mit Graph‑Client verwalten

Kalendereinträge verwalten

Aspose.Email bietet APIs zum Zugreifen, Verwalten und Interagieren mit Kalendereinträgen. Zu diesem Zweck stellt es die folgenden Methoden bereit in der IGraphClient Schnittstelle:

  • ListCalendars() – Gibt eine Sammlung von Kalenderinformationen zurück.
  • ListCalendarItems(string id) – Gibt eine Sammlung von Kalendereinträgen zurück, die mit der angegebenen Kalender‑ID verknüpft sind.
  • FetchCalendarItem(string id) – Ruft einen bestimmten Kalendereintrag anhand der angegebenen ID ab.
  • CreateCalendarItem(string calId, MapiCalendar mapiCalendar) – Erstellt einen neuen Kalendereintrag im angegebenen Kalender.
  • UpdateCalendarItem(MapiCalendar mapiCalendar) – Aktualisiert einen bestehenden Kalendereintrag.
  • UpdateCalendarItem(MapiCalendar mapiCalendar, UpdateSettings updateSettings) – Aktualisiert einen bestehenden Kalendereintrag mit den angegebenen Aktualisierungseinstellungen.

Das folgende Codebeispiel zeigt, wie Sie mit Kalendereinträgen in einem Microsoft Graph API‑Client unter Verwendung der von Aspose.Email bereitgestellten Methoden interagieren können:


// List Calendars
CalendarInfoCollection calendars = graphClient.ListCalendars();

// List Calendar Items
MapiCalendarCollection calendarItems = graphClient.ListCalendarItems("calendarId");

// Fetch Calendar Item
MapiCalendar calendarItem = graphClient.FetchCalendarItem("calendarItemId");

// Create Calendar Item
MapiCalendar newCalendarItem = new MapiCalendar(
    location: "Conference Room",
    summary: "Team Meeting",
    description: "Discuss project status and updates.",
    startDate: startDate,
    endDate: endDate
);

MapiCalendar createdCalendarItem = graphClient.CreateCalendarItem("calendarId", newCalendarItem);

// Update Calendar Item
createdCalendarItem.Location = "Zoom Meeting";
MapiCalendar updatedCalendarItem = graphClient.UpdateCalendarItem(createdCalendarItem);

Kategorien verwalten

Um Kategorien mit MS Graph von Aspose.Email für .NET zu verwalten, verwenden Sie die folgenden Methoden:

// create a custom category with Orange color
var category = client.CreateCategory("My custom category", CategoryPreset.Preset1);

// fetch a category
var fetchedCategory = client.FetchCategory(category.Id);

// update category (change color to brown)
fetchedCategory.Preset = CategoryPreset.Preset2;
var updatedCategory = client.UpdateCategory(fetchedCategory);

// list available categories
var categories = client.ListCategories();

foreach (var cat in categories)
{
    Console.WriteLine(cat.DisplayName);
}

// delete a category
client.Delete(fetchedCategory.Id);

Kontakte verwalten

Aspose.Email bietet APIs zum Zugreifen, Verwalten und Interagieren mit Kontaktdatensätzen. Zu diesem Zweck stellt es die folgenden Methoden bereit in der IGraphClient Schnittstelle:

  • ListContacts(string id) – Gibt eine Sammlung von MAPI‑Kontakten zurück, die mit der angegebenen Ordner‑ID verknüpft sind.
  • FetchContact(string id) – Ruft einen bestimmten Kontakt anhand der angegebenen Element‑ID ab.
  • CreateContact(string folderId, MapiContact contact) – Erstellt einen neuen Kontakt im angegebenen Ordner.
  • UpdateContact(MapiContact contact) – Aktualisiert einen bestehenden Kontakt.

Das folgende Codebeispiel zeigt, wie Sie mit Kontakten in einem Microsoft Graph API‑Client unter Verwendung der von Aspose.Email bereitgestellten Methoden interagieren können:

// List Contacts
MapiContactCollection contacts = graphClient.ListContacts("contactFolderId");

// Fetch Contact
MapiContact contact = graphClient.FetchContact("contactId");

// Create Contact
MapiContact newContact = new MapiContact("Jane Smith", "jane.smith@example.com", "XYZ Corporation", "777-888-999");

MapiContact createdContact = graphClient.CreateContact("contactFolderId", newContact);

// Update Contact
createdContact.Telephones.PrimaryTelephoneNumber = "888-888-999";

MapiContact updatedContact = graphClient.UpdateContact(createdContact);

Overrides verwalten

Um Overrides mit MS Graph von Aspose.Email für .NET zu verwalten, verwenden Sie die folgenden Methoden:

// Create an user's override
var userOverride = client.CreateOrUpdateOverride
    (new MailAddress("JohnBrown@someorg.com", "JohnBrown"), ClassificationType.Focused);

// list the overrides
var overrides = client.ListOverrides();

// update override
userOverride.Sender.DisplayName = "John Brown";
var updatedOverride = client.UpdateOverride(userOverride);

// delete override
client.Delete(updatedOverride.Id);

Regeln verwalten

Um Regeln mit MS Graph von Aspose.Email für .NET zu verwalten, verwenden Sie die folgenden Methoden:

// Create a rule
var rule = PrepareRule("user@someorg.com", "User");
var createdRule = client.CreateRule(rule);

// List all rules defined for Inbox
var rules = client.ListRules();

// Fetch a rule
var fetchedRule = client.FetchRule(createdRule.RuleId);

// Update a rule
fetchedRule.DisplayName = "Renamed rule";
fetchedRule.IsEnabled = false;
var updatedRule = client.UpdateRule(createdRule);

// Delete a rule
client.Delete(updatedRule.RuleId);

InboxRule PrepareRule(string email, string displayName)
{
    var rule = new InboxRule()
    {
        DisplayName = "My rule",
        Priority = 1,
        IsEnabled = true,
        Conditions = new RulePredicates(),
        Actions = new RuleActions()
    };

    rule.Conditions.ContainsSenderStrings = new StringCollection { displayName };
    rule.Actions.ForwardToRecipients = new MailAddressCollection
        { new MailAddress(email, displayName, true) };
    rule.Actions.StopProcessingRules = true;

    return rule;
}

Notizbücher verwalten

Um Notizbücher mit MS Graph von Aspose.Email für .NET zu verwalten, verwenden Sie die folgenden Methoden:

// create a OneNote notebook
var newNotebook = new Notebook()
{
    DisplayName = "My Notebook"
};
var createdNotebook = client.CreateNotebook(newNotebook);

// fetch a notebook
var fetchedNotebook = client.FetchNotebook(createdNotebook.Id);

// list the notebooks
var notebooks = client.ListNotebooks();

Aufgabenverwaltung in Microsoft Graph

Aspose.Email bietet Entwicklern APIs zum Zugriff, zur Verwaltung und Interaktion mit den Aufgaben und Aufgabenlisten von Benutzern unter Verwendung der folgenden Methoden von IGraphClient Schnittstelle:

Das folgende Code‑Beispiel demonstriert, wie man Aufgabenlisten verwaltet:

// List Task Lists
var taskLists = graphClient.ListTaskLists();

foreach (var tList in taskLists)
{
    Console.WriteLine($"Task List: {tList.DisplayName}");
}

// Get Task List
var taskList = graphClient.GetTaskList("taskListId");

// Delete Task List
graphClient.DeleteTaskList("taskListId");

Das folgende Code‑Beispiel demonstriert, wie man Aufgaben verwaltet:

// List Tasks in a Task List
MapiTaskCollection tasks = graphClient.ListTasks("taskListId");

// Fetch Task
MapiTask task = graphClient.FetchTask("taskId");

// Create Task
var newTask = new MapiTask
{
    Subject = "New Task",
    DueDate = new DateTime(2023, 12, 31),
    Status = MapiTaskStatus.NotStarted
};

MapiTask createdTask = graphClient.CreateTask(newTask, "taskListUri");

// Update Task
createdTask.Subject = "Updated Task Subject";
MapiTask updatedTask = graphClient.UpdateTask(createdTask);

// Update Task with UpdateSettings
var updateSettings = new UpdateSettings { SkipAttachments  = true };
MapiTask updatedTaskWithSettings = graphClient.UpdateTask(createdTask, updateSettings);
Erstellen eines Projekts im Azure Active Directory Admin Center Verwalten von Mail‑Ordnern in Microsoft Graph (Aspose.Email)