Dostęp i zarządzanie danymi Microsoft 365 przy użyciu Microsoft Graph

Optymalizuj dostęp i zarządzanie danymi Microsoft 365 przy użyciu Aspose.Email Graph Client

Microsoft Graph jest interfejsem REST API umożliwiającym dostęp do danych Microsoft 365. Implementacja Graph Client w Aspose.Email dla .NET pozwala na dostęp do Microsoft Graph z naszego API. W poniższych przykładach utworzymy instancję MS Graph Client, przekazując token. Następnie przyjrzymy się głównym metodom zarządzania folderami, ich aktualizacji, kopiowaniu i usuwaniu. Wiadomości, ich zawartość oraz załączniki również mogą być dostępne lub modyfikowane przy użyciu naszego MS Graph Client. Zarządzanie kategoriami, regułami, notatnikami i nadpisaniami jest rozszerzoną funkcją Microsoft Graph Client od Aspose.Email.

Uwierzytelnianie i żądania przy użyciu IGraphClient z MSAL w .NET

Aby współpracować z usługami Microsoft Graph, musisz utworzyć IGraphClient obiekt. Po uwierzytelnieniu ten klient umożliwia wykonywanie różnych żądań usługowych. GetClient metody, która tworzy IGraphClient, wymaga ITokenProvider implementacji jako pierwszego parametru. To ITokenProvider odpowiedzialna jest za dostarczanie niezbędnego tokenu uwierzytelniającego. Aby uzyskać token, użyjemy Biblioteka Microsoft Authentication Library (MSAL) dla .NET.

Oto, jak skonfigurować proces uwierzytelniania:

Krok 1: Konfiguracja uwierzytelniania

Poniższe kroki poprowadzą Cię, jak uzyskać token autoryzacji:

  1. Utwórz klasę AccessParameters.

    Zdefiniuj klasę AccessParameters do przechowywania swoich poświadczeń.

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. Dodaj Pakiet MSAL.NET**.

    Zainstaluj Microsoft.Identity.Client Pakiet NuGet, który zawiera binaria MSAL.NET potrzebne do uwierzytelniania.

  2. Implementuj interfejs ITokenProvider.

    Utwórz GraphTokenProvider klasa, która implementuje ITokenProvider interfejs. Ta klasa będzie używać biblioteki MSAL.NET do uzyskania tokenu dostępu.

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

Krok 2: Utwórz instancję ITokenProvider

Po zdefiniowaniu GraphTokenProvider klasy, możesz utworzyć instancję AccessParameters i użyj go do utworzenia instancji 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);

Krok 3: Wykonywanie żądań przy użyciu IGraphClient

Na koniec, użyj GraphTokenProvider aby utworzyć uwierzytelniony IGraphClient i możesz rozpocząć wykonywanie żądań serwisowych.

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

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

Po wykonaniu tych kroków, Twój IGraphClient jest już gotowy do interakcji z usługami Microsoft Graph przy użyciu uwierzytelnionych żądań.

Łączenie z końcówkami GCC High

Ten GraphClient obsługuje połączenia z końcówkami GCC High przy użyciu EndPoint właściwość. Poniższy przykład kodu pokazuje, jak skonfigurować GraphClient do połączenia z końcówką GCC High w celu wyświetlania folderów i pobierania wiadomości.

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

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

Zarządzaj folderami za pomocą IGraphClient

Wyświetl foldery

Poprzez wywołanie ListFolders metoda z MS Graph Client, umożliwia pobranie listy folderów. Każdy folder posiada zestaw parametrów, takich jak DisplayName, które można odczytać w FolderInfo typ.

var folders = client.ListFolders();

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

Aktualizuj foldery

Aby utworzyć folder przy użyciu MS Graph Client, użyj CreateFolder metoda. Otrzymasz FolderInfo obiekt oraz możliwość dostępu do właściwości DisplayName, ItemId, HasSubFolders i innych.

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

Kopiuj foldery

CopyFolder metoda jest główną metodą kopiowania obiektu folderu przy użyciu MS Graph.

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

Przenieś i usuń foldery

Użyj MoveFolder metoda służy do przeniesienia folderu, przyjmuje newParentId i itemId. Usuń metoda służy do usunięcia elementu po identyfikatorze.

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)

Zarządzaj wiadomościami za pomocą IGraphClient

Klient MS Graph, zaimplementowany w Aspose.Email dla .NET, udostępnia zestaw metod do zarządzania wiadomościami i załącznikami:

Wyświetl wiadomości

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

Filtrowanie wiadomości według daty wysłania

Ten OrderBy metoda z kolekcji bibliotecznej umożliwia pobranie wiadomości w różnych kolejnościach sortowania (rosnącej i malejącej) w oparciu o datę wysłania. Poniższy przykład kodu pokazuje, jak posortować wiadomości według daty ich wysłania:

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;

Enumeruj wiadomości ze wsparciem stronicowania

API umożliwia stronicowanie i filtrowanie wiadomości podczas ich wyświetlania. Jest to szczególnie przydatne przy skrzynkach pocztowych o dużej liczbie wiadomości, ponieważ oszczędza czas, pobierając tylko niezbędne informacje podsumowujące.

Poniższy przykład kodu i opisane kroki pokazują, jak pobrać wiadomości z folderu Inbox przy użyciu funkcji stronicowania i filtrowania.

  1. Najpierw zainicjuj klienta.
  2. Następnie ustaw liczbę elementów wyświetlanych na stronę, na przykład 10.
  3. Utwórz filtr, aby pobrać wyłącznie nieprzeczytane wiadomości przy użyciu GraphQueryBuilder klasa. builder.IsRead.Equals(false) ustawia warunek filtracji nieprzeczytanych wiadomości.
  4. Wywołaj ListMessages metoda na obiekcie klienta, określająca folder (Inbox) oraz liczbę elementów na stronę (PageInfo(itemsPerPage)) jako parametry. Przekazuje również obiekt zapytania, aby zastosować filtr nieprzeczytanych wiadomości. Zwrócony obiekt PageInfo (pageInfo) zawiera pobrane wiadomości dla bieżącej strony w własności Items.
  5. Utwórz pętlę, która trwa aż do osiągnięcia ostatniej strony (pageInfo.LastPage jest false). Pobranе wiadomości są dodawane do istniejącej listy wiadomości przy użyciu 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);
}

Pobierz wiadomości

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

Utwórz wiadomości

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

Wyślij wiadomości

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

Wyślij wersje robocze wiadomości

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

Wyślij wiadomości EML

Tworzenie i wysyłanie e‑maili jest proste przy użyciu obiektu MailMessage. Poniższy przykład kodu pokazuje, jak utworzyć i wysłać wiadomość e‑mail przy użyciu 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);

Kopiuj wiadomości


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

Przenieś wiadomości

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

Zarządzanie załącznikami


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

Zarządzaj elementami Outlook przy użyciu Graph Client

Zarządzaj wydarzeniami kalendarza

Aspose.Email udostępnia API do dostępu, zarządzania i interakcji z wydarzeniami kalendarza. W tym celu oferuje następujące metody w IGraphClient interfejs:

  • ListCalendars() — pobiera kolekcję informacji o kalendarzach.
  • ListCalendarItems(string id) — pobiera kolekcję elementów kalendarza powiązanych z określonym identyfikatorem kalendarza.
  • FetchCalendarItem(string id) — pobiera określony element kalendarza na podstawie podanego identyfikatora.
  • CreateCalendarItem(string calId, MapiCalendar mapiCalendar) — tworzy nowy element kalendarza w określonym kalendarzu.
  • UpdateCalendarItem(MapiCalendar mapiCalendar) — aktualizuje istniejący element kalendarza.
  • UpdateCalendarItem(MapiCalendar mapiCalendar, UpdateSettings updateSettings) — aktualizuje istniejący element kalendarza przy użyciu określonych ustawień aktualizacji.

Poniższy przykład kodu pokazuje, jak wchodzić w interakcję z wydarzeniami kalendarza w kliencie Microsoft Graph API, używając metod udostępnionych przez Aspose.Email:


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

Zarządzaj kategoriami

Aby zarządzać kategoriami przy użyciu MS Graph w Aspose.Email dla .NET, użyj następujących metod:

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

Zarządzaj kontaktami

Aspose.Email udostępnia API do dostępu, zarządzania i interakcji z elementami kontaktów. W tym celu oferuje następujące metody w IGraphClient interfejs:

  • ListContacts(string id) — pobiera kolekcję kontaktów MAPI powiązanych z określonym identyfikatorem folderu.
  • FetchContact(string id) — pobiera określony kontakt na podstawie podanego identyfikatora elementu.
  • CreateContact(string folderId, MapiContact contact) — tworzy nowy kontakt w określonym folderze.
  • UpdateContact(MapiContact contact) — aktualizuje istniejący kontakt.

Poniższy przykład kodu pokazuje, jak wchodzić w interakcję z kontaktami w kliencie Microsoft Graph API, używając metod udostępnionych przez Aspose.Email:

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

Zarządzaj nadpisaniami

Aby zarządzać nadpisaniami przy użyciu MS Graph w Aspose.Email dla .NET, użyj następujących metod:

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

Zarządzaj regułami

Aby zarządzać regułami przy użyciu MS Graph w Aspose.Email dla .NET, użyj następujących metod:

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

Zarządzaj notatnikami

Aby zarządzać notatnikami przy użyciu MS Graph w Aspose.Email dla .NET, użyj następujących metod:

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

Zarządzanie zadaniami w Microsoft Graph

Aspose.Email udostępnia programistom API do dostępu, zarządzania i interakcji z zadaniami i listami zadań użytkowników przy użyciu następujących metod IGraphClient interfejs:

Poniższy przykład kodu demonstruje, jak zarządzać listami zadań:

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

Poniższy przykład kodu demonstruje, jak zarządzać zadaniami:

// 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);
Tworzenie projektu w centrum administracyjnym Azure Active Directory Zarządzanie folderami poczty w Microsoft Graph (Aspose.Email)