Microsoft 365 Gegevens‑toegang en beheer met Microsoft Graph

Optimaliseer de toegang tot en het beheer van Microsoft 365-gegevens met Aspose.Email Graph Client

Microsoft Graph is een REST‑API om toegang te krijgen tot de Microsoft 365‑gegevens. De implementatie van Graph Client in Aspose.Email voor .NET maakt toegang tot Microsoft Graph mogelijk vanuit onze API. In de onderstaande voorbeelden maken we een instantie van MS Graph Client, waarbij we het token verstrekken. Vervolgens bekijken we de belangrijkste methoden om mappen te beheren, bij te werken, te kopiëren en te verwijderen. Berichten, hun inhoud en bijlagen kunnen ook worden benaderd of gewijzigd met onze MS Graph Client. Het beheren van categorieën, regels, notitieblokken en overrides is een uitgebreide functie van Microsoft Graph Client door Aspose.Email.

Authenticeren en verzoeken met IGraphClient via MSAL in .NET

Om te communiceren met Microsoft Graph-services, moet u een IGraphClient object. Zodra u geauthenticeerd bent, stelt deze client u in staat verschillende serviceverzoeken uit te voeren. De GetClient methode, die de IGraphClient, vereist een ITokenProvider implementatie als eerste parameter. Deze ITokenProvider is verantwoordelijk voor het leveren van het benodigde authenticatietoken. Om het token te verkrijgen, gebruiken we de Microsoft Authentication Library (MSAL) voor .NET.

Zo stelt u het authenticatieproces in:

Stap 1: Authenticatie instellen

De volgende stappen begeleiden u bij het verkrijgen van een autorisatietoken:

  1. Maak de AccessParameters-klasse.

    Definieer een AccessParameters-klasse om uw referenties op te slaan.

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. Voeg de MSAL.NET-pakket**.

    Installeer de Microsoft.Identity.Client NuGet-pakket, dat de MSAL.NET-binaries bevat die nodig zijn voor authenticatie.

  2. Implementeer de ITokenProvider-interface.

    Maak een GraphTokenProvider klasse die de ITokenProvider interface. Deze klasse zal de MSAL.NET-bibliotheek gebruiken om een toegangstoken te verkrijgen.

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

Stap 2: Maak een ITokenProvider‑instantie

Na het definiëren van de GraphTokenProvider klasse te instantieren, je kunt een instantie maken van AccessParameters en gebruik het om de 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);

Stap 3: Verzoeken doen met IGraphClient

Gebruik tenslotte de GraphTokenProvider om een geauthenticeerde IGraphClient en begin met het doen van service‑verzoeken.

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

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

Met deze stappen voltooid, jouw IGraphClient is nu klaar om te communiceren met Microsoft Graph‑services via geauthenticeerde verzoeken.

Verbinden met GCC High‑eindpunten

De GraphClient ondersteunt verbinding met GCC High‑eindpunten door gebruik te maken van de EndPoint eigenschap. Het volgende codevoorbeeld toont hoe de GraphClient te configureren om verbinding te maken met het GCC High‑eindpunt voor het opsommen van mappen en het ophalen van berichten.

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

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

Beheer Mappen met IGraphClient

Mappen weergeven

Door aan te roepen ListFolders methode van MS Graph Client, het is mogelijk de lijst met mappen op te halen. Elke map heeft een reeks parameters zoals DisplayName, die gelezen kan worden in FolderInfo type.

var folders = client.ListFolders();

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

Update Mappen

Om een map te maken met MS Graph Client, gebruik CreateFolder methode. Je krijgt een FolderInfo object en de mogelijkheid om DisplayName, ItemId, HasSubFolders en andere eigenschappen te benaderen.

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

Kopieer Mappen

CopyFolder methode is de belangrijkste methode om het map‑object te kopiëren met MS Graph.

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

Verplaats en Verwijder Mappen

Gebruik MoveFolder methode wordt gebruikt om de map te verplaatsen, het accepteert newParentId en itemId. Verwijderen methode wordt gebruikt om een methode te verwijderen op basis van id.

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)

Beheer Berichten met IGraphClient

MS Graph Client, geïmplementeerd in Aspose.Email voor .NET, biedt een reeks methoden om berichten en bijlagen te beheren:

Berichten Lijst

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

Filter berichten op verzenddatum

De OrderBy methode uit de bibliotheekcollectie maakt het mogelijk berichten op te halen met verschillende sorteerorders (oplopend en aflopend) op basis van de verzenddatum. De volgende codevoorbeeld toont hoe berichten te sorteren op verzenddatum:

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;

Opsommen van berichten met paginering

De API ondersteunt paginering en filtering van berichten bij het opsommen ervan. Het is vooral nuttig voor mailboxen met een groot aantal berichten, omdat het tijd bespaart door alleen de benodigde samenvattende informatie op te halen.

Het codevoorbeeld en de onderstaande stappen tonen hoe berichten uit de Inbox‑map op te halen met paginering en filterfuncties.

  1. Start eerst de client.
  2. Stel vervolgens het aantal items per pagina in, bijvoorbeeld 10.
  3. Maak een filter om alleen ongelezen berichten op te halen met behulp van de GraphQueryBuilder klasse. De builder.IsRead.Equals(false) stelt de voorwaarde in voor het filteren van ongelezen berichten.
  4. Roep de ListMessages methode op het client‑object, waarbij de map (Inbox) en het aantal items per pagina (PageInfo(itemsPerPage)) als parameters worden opgegeven. Het geeft ook het query‑object door om het filter voor ongelezen berichten toe te passen. Het geretourneerde PageInfo‑object (pageInfo) bevat de opgehaalde berichten voor de huidige pagina in de Items‑eigenschap.
  5. Maak een lus die doorgaat tot de laatste pagina is bereikt (pageInfo.LastPage is false). De opgehaalde berichten worden toegevoegd aan de bestaande berichtenlijst met 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);
}

Haal Berichten op

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

Maak Berichten

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

Verzend Berichten

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

Verzend Concept‑berichten

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

Verzend EML‑berichten

E-mail maken en verzenden is eenvoudig met het MailMessage‑object. De volgende codevoorbeeld toont hoe een e‑mailbericht te maken en te verzenden met de Graph‑API:

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

Kopieer Berichten


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

Verplaats Berichten

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

Beheer bijlagen


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

Beheer Outlook‑items met Graph‑client

Beheer Agenda‑gebeurtenissen

Aspose.Email biedt API’s om agenda‑gebeurtenissen te benaderen, beheren en ermee te interacteren. Hiervoor biedt het de volgende methoden in de IGraphClient interface:

  • ListCalendars() - Haalt een verzameling agenda‑informatie op.
  • ListCalendarItems(string id) - Haalt een verzameling agenda-items op die gekoppeld zijn aan de opgegeven agenda-ID.
  • FetchCalendarItem(string id) - Haalt een specifiek agenda-item op op basis van de opgegeven ID.
  • CreateCalendarItem(string calId, MapiCalendar mapiCalendar) - Maakt een nieuw agenda-item aan in de opgegeven agenda.
  • UpdateCalendarItem(MapiCalendar mapiCalendar) - Werkt een bestaand agenda-item bij.
  • UpdateCalendarItem(MapiCalendar mapiCalendar, UpdateSettings updateSettings) - Werkt een bestaand agenda-item bij met de opgegeven update‑instellingen.

De volgende codevoorbeeld toont hoe te communiceren met agenda‑gebeurtenissen in een Microsoft Graph API-client met behulp van de methoden die door Aspose.Email worden geleverd:


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

Beheer Categorieën

Om categorieën te beheren met MS Graph via Aspose.Email voor .NET, gebruik de volgende 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);

Beheer Contacten

Aspose.Email biedt API’s om contactitems te benaderen, beheren en ermee te interacteren. Hiervoor biedt het de volgende methoden in de IGraphClient interface:

  • ListContacts(string id) - Haalt een verzameling MAPI-contacten op die gekoppeld zijn aan de opgegeven map-ID.
  • FetchContact(string id) - Haalt een specifiek contact op op basis van de opgegeven item-ID.
  • CreateContact(string folderId, MapiContact contact) - Maakt een nieuw contact aan in de opgegeven map.
  • UpdateContact(MapiContact contact) - Werkt een bestaand contact bij.

De volgende codevoorbeeld toont hoe te communiceren met contacten in een Microsoft Graph API-client met behulp van de methoden die door Aspose.Email worden geleverd:

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

Beheer Overrides

Om overrides te beheren met MS Graph via Aspose.Email voor .NET, gebruik de volgende 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);

Beheer Regels

Om regels te beheren met MS Graph via Aspose.Email voor .NET, gebruik de volgende 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;
}

Beheer Notitieblokken

Om notitieblokken te beheren met MS Graph via Aspose.Email voor .NET, gebruik de volgende 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();

Takenbeheer in Microsoft Graph

Aspose.Email biedt ontwikkelaars API’s om toegang te krijgen tot, te beheren en te communiceren met taken en takenlijsten van gebruikers met behulp van de volgende methoden van de IGraphClient interface:

Het volgende codevoorbeeld toont hoe u takenlijsten beheert:

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

Het volgende codevoorbeeld toont hoe u taken beheert:

// 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);
Een project maken in het Azure Active Directory-beheercentrum E‑mailmappen beheren in Microsoft Graph (Aspose.Email)