Zarządzanie Skrzynką Pocztową z Microsoft Graph i .NET API

• Prezentacja Microsoft Graph
• O bibliotece Aspose.Email dla .NET
• Skonfiguruj swoją aplikację w Azure Portal
• Uzyskaj token dostępu i zainicjalizuj GraphClient
  • Krok 1: Utwórz plik konfiguracyjny
  • Krok 2: Mapuj konfigurację JSON do obiektu C#
  • Krok 3: Uzyskaj token dostępu
  • Krok 4: Zainicjalizuj GraphClient
• Uzyskaj hierarchię folderów i pobierz foldery według nazwy
  • Krok 1: Zrozumienie hierarchii folderów
    • Nawigacja po strukturze folderów
  • Krok 2: Pobierz hierarchię folderów
  • Krok 3: Pobierz foldery według nazwy
• Listuj wiadomości w określonym folderze

Integracja Microsoft Graph API i biblioteki Aspose.Email dla .NET z aplikacją e-mail pozwala programistom na łatwy dostęp i manipulowanie danymi skrzynki pocztowej, wykonywanie operacji takich jak pobieranie wiadomości, uzyskiwanie hierarchii folderów oraz zapisywanie e-maili w różnych formatach. W tym artykule zbadamy, jak wykorzystać to potężne połączenie w przetwarzaniu i zarządzaniu skrzynkami pocztowymi.

Prezentacja Microsoft Graph

Microsoft Graph to kompleksowa platforma API dostarczana przez Microsoft, która oferuje zunifikowany punkt dostępu do szerokiego zakresu usług i danych Microsoft. Służy jako brama do ogromnych danych dostępnych w Microsoft 365, w tym skrzynek pocztowych Outlook, kalendarzy, kontaktów, OneDrive, Teams i innych.

Dzięki Microsoft Graph programiści mogą tworzyć aplikacje, które płynnie współdziałają z danymi użytkowników i spostrzeżeniami w ekosystemie chmury Microsoft. Osiąga się to dzięki RESTful API i SDK, które zapewniają środki do uwierzytelniania, autoryzacji i łatwego zapytania o dane.

O bibliotece Aspose.Email dla .NET

Aspose.Email dla .NET jest bogatą w funkcje biblioteką, która umożliwia programistom pracę z plikami e-mail i protokołami w ich aplikacjach .NET. Oferuje solidny zestaw API do tworzenia, manipulowania i konwertowania wiadomości e-mail w różnych formatach, takich jak MSG, EML i MBOX. Dodatkowo biblioteka obsługuje protokoły e-mail, takie jak SMTP, POP3 i IMAP, co pozwala na wszechstronne zarządzanie e-mailem.

W tym przewodniku użyjemy Aspose.Email do interakcji z Microsoft Graph, przetwarzając dane skrzynki pocztowej programowo. Dzięki GraphClient z Aspose.Email możemy efektywnie wykonywać operacje na skrzynkach pocztowych, uwierzytelniając się z Microsoft Graph.

Aby rozpocząć korzystanie z biblioteki, musisz zintegrować ją z projektem. Najłatwiejszym sposobem na uzyskanie Aspose.Email dla .NET jest użycie menedżera pakietów NuGet:

• Otwórz projekt w Visual Studio.
• Przejdź do Narzędzia > Menedżer pakietów NuGet > Zarządzaj pakietami NuGet dla rozwiązania.
• Wyszukaj Aspose.Email.
• Wybierz pakiet i kliknij Instaluj.

Alternatywnie możesz użyć konsoli menedżera pakietów:

Install-Package Aspose.Email

Możesz również pobrać najnowszą wersję API bezpośrednio z strony Aspose.

Skonfiguruj swoją aplikację w Azure Portal

Zanim przejdziemy do kodu, ważne jest skonfigurowanie aplikacji w portalu Azure, aby umożliwić dostęp do Microsoft Graph. Wystarczy wykonać następujące kroki:

1. Utwórz aplikację Azure Active Directory (AAD):

   • Przejdź do Azure Portal.
   • Przejdź do Azure Active Directory > Rejestracje aplikacji.
   • Kliknij Nowa rejestracja, aby utworzyć nową aplikację.
   • Podaj nazwę i ustaw URI przekierowania, jeśli to konieczne.
   • Kliknij Zarejestruj, aby zakończyć proces.

2. Ustaw uprawnienia API:

   • W swojej zarejestrowanej aplikacji przejdź do Uprawnienia API.
   • Kliknij Dodaj uprawnienie > Microsoft Graph.
   • Wybierz Uprawnienia aplikacji dla połączeń serwerowych.
   • Wybierz niezbędne uprawnienia, takie jak Mail.Read, Mail.ReadWrite, User.Read itp.
   • Kliknij Dodaj uprawnienia, aby zastosować.

3. Utwórz tajny klucz klienta:

   • Przejdź do Certyfikaty i tajne klucze w swojej aplikacji.
   • Kliknij Nowy tajny klucz klienta i podaj opis.
   • Ustaw okres ważności, a następnie kliknij Dodaj.
   • Zanotuj wygenerowaną wartość tajnego klucza klienta, ponieważ będziesz jej potrzebować później.

4. Zgromadź wartości konfiguracyjne:

   • Uzyskaj Identyfikator dzierżawy, Identyfikator klienta i Tajny klucz klienta z przeglądarki Twojej aplikacji oraz sekcji tajnych kluczy.
   • Użyjesz tych wartości do uwierzytelnienia i interakcji z Microsoft Graph.

Gdy Twoja aplikacja jest skonfigurowana, jesteś gotowy, aby przejść do zadań deweloperskich.

Uzyskaj token dostępu i zainicjalizuj GraphClient

Zanim zanurzymy się w operacjach na skrzynkach pocztowych, musimy otworzyć drzwi do ogromnego ekosystemu danych i usług Microsoft Graph. Dostęp ten jest przyznawany przez token dostępu OAuth 2.0 - cyfrowy klucz, który autoryzuje Twoją aplikację do interakcji z Microsoft Graph w imieniu użytkownika lub usługi. Wyobraź sobie to jako bezpieczny bilet, który zapewnia Ci wejście do całego uniwersum możliwości, od pobierania e-maili po zarządzanie kontaktami i nie tylko.

Krok 1: Utwórz plik konfiguracyjny

Pierwszym krokiem w uzyskaniu tokenu jest utworzenie pliku konfiguracyjnego, który przechowuje istotne szczegóły, takie jak Identyfikator dzierżawy, Identyfikator klienta i Tajny klucz klienta Twojej aplikacji. Te wartości stanowią dane uwierzytelniające Twojej aplikacji i działają jako identyfikatory podczas komunikacji z serwerami Microsoft.

Oto jak może wyglądać Twoja konfiguracja JSON:

{
    "Instance": "https://login.microsoftonline.com/{0}",
    "ApiUrl": "https://graph.microsoft.com/.default",
    "TenantId": "YOUR_TENANT_ID_HERE",
    "ClientId": "YOUR_APP_ID_HERE",
    "ClientSecret": "YOUR_CLIENT_SECRET_HERE",
    "UserId": "YOUR_ID_HERE"
}

Krok 2: Mapuj konfigurację JSON do obiektu C#

Teraz przekształćmy tę konfigurację w obiekt C#, którego nasza aplikacja może użyć. Odczytamy plik JSON i przemapujemy jego zawartość na klasę AuthenticationConfig, zapewniając, że nasza aplikacja wie, gdzie znaleźć kluczowe informacje, których potrzebuje.

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

Krok 3: Uzyskaj token dostępu

Gdy nasza konfiguracja jest gotowa, czas na uzyskanie tokenu dostępu. Zaimplementujemy klasę GraphTokenProvider, która obsługuje proces uwierzytelniania za pomocą Microsoft Authentication Library (MSAL). Ta klasa zajmuje się ciężką pracą - komunikacją z Microsoft Graph, aby uzyskać token, który uprawnia naszą aplikację.

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

        // W pamięci tokeny cache (cache aplikacji i użytkownika)
        _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($"Token uzyskany z {result.AuthenticationResultMetadata.TokenSource} {Environment.NewLine}");
        }
        catch (MsalServiceException ex)
        {
            Console.WriteLine($"Błąd uzyskiwania tokenu:{Environment.NewLine}{ex}{Environment.NewLine}");
            result = null;
        }

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

Krok 4: Zainicjalizuj GraphClient

Na koniec inicjalizujemy GraphClient za pomocą uzyskanego tokenu. GraphClient działa jako nasz most do Microsoft Graph, pozwalając na płynne interakcje z użytkownikami skrzynek pocztowych.

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;

Uzyskaj hierarchię folderów i pobierz foldery według nazwy

Gdy uzyskasz dostęp do Microsoft Graph, czas na odkrywanie skrzynki pocztowej. W tej sekcji zagłębimy się w uzyskiwanie i nawigację po hierarchii folderów skrzynki pocztowej, umożliwiając dostęp do konkretnych folderów według nazwy.

Krok 1: Zrozumienie hierarchii folderów

Nawigacja po strukturze folderów

Skrzynki pocztowe są zorganizowane hierarchicznie, podobnie jak drzewo. Folder główny dzieli się na kilka podfolderów, z których każdy zawiera własny zestaw e-maili i potencjalnie więcej podfolderów. Ta zagnieżdżona struktura pozwala na uporządkowane zarządzanie i łatwą nawigację po e-mailach.

Zdefiniujmy i użyjmy klasy FolderNode, aby reprezentować każdy folder w hierarchii:

// Reprezentuje węzeł w hierarchii folderów,
// rozszerzając właściwości FolderInfo i przechowując kolekcję subfolderów.
class FolderNode
{
    // Gets the FolderInfo object representing the folder information.
    public FolderInfo Folder { get; }
    
    // Gets the collection of subfolders contained within the current folder.
    public List<FolderNode?> SubFolders { get; }

    // Initializes a new instance of the FolderNode class with the specified FolderInfo object.
    public FolderNode(FolderInfo folder)
    {
        Folder = folder;
        SubFolders = new List<FolderNode?>();
    }
    
    // Prints all folders in a hierarchical manner starting from the current node.
    public void PrintHierarchy()
    {
        PrintFolderNode(this, 0);
    }

    private void PrintFolderNode(FolderNode node, int indentLevel)
    {
        // Print current folder node with indentation
        Console.WriteLine($"{new string(' ', indentLevel * 2)}{node}");

        // Recursively print subfolders
        foreach (var subFolder in node.SubFolders)
        {
            PrintFolderNode(subFolder, indentLevel + 1);
        }
    }

    // Get the folder Display Name.
    public override string ToString()
    {
        return $"{Folder.DisplayName} ({Folder.ContentCount})";
    }
}

Aby uzyskać pełną hierarchię folderów, stworzymy klasę FolderHierarchy, która wykorzystuje GraphClient, aby rekurencyjnie wymieniać wszystkie foldery. Oto jak to działa:

static class FolderHierarchy
{
    // Retrieves all folders in the mailbox recursively and returns a hierarchical collection of FolderNode objects.
    public static List<FolderNode> Retrieve(IGraphClient client)
    {
        // Retrieve root folders
        var rootFolders = client.ListFolders();
        var allFolders = new List<FolderNode>();

        // Retrieve subfolders recursively
        foreach (var folder in rootFolders)
        {
            var folderNode = new FolderNode(folder);
            RetrieveSubFolders(client, folderNode);
            allFolders.Add(folderNode);
        }

        return allFolders;
    }

    // Retrieves subfolders recursively and adds them to the parent FolderNode's SubFolders property.
    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);
            }
        }
    }
}

Krok 2: Pobierz hierarchię folderów

Korzystając z metody FolderHierarchy.Retrieve, możesz bez trudu przeszukiwać skrzynkę pocztową, aby odkryć jej strukturę folderów. Oto jak możesz to osiągnąć:

// Retrieve the folder hierarchy from the mailbox
var folderNodes = FolderHierarchy.Retrieve(client);

// Print the folder hierarchy in a structured format
foreach (var folderNode in folderNodes)
{
    folderNode.PrintHierarchy();
}

Krok 3: Pobierz foldery według nazwy

Gdy hierarchia folderów zostanie pobrana, możesz zidentyfikować konkretne foldery według nazwy. Niezależnie od tego, czy interesuje Cię dostęp do Skrzynki Odbiorczej, czy jakiegokolwiek folderu niestandardowego, ta metoda zapewnia szybkie ich zlokalizowanie:

// Specify the folder name you're looking for
string targetFolderName = "Skrzynka odbiorcza";

// Locate the target folder by name
var targetFolder = folderNodes.FirstOrDefault(
    folderNode => folderNode.Folder.DisplayName.Equals(targetFolderName, StringComparison.OrdinalIgnoreCase))
    ?.Folder;

Listuj wiadomości w określonym folderze

Po skutecznym pobraniu hierarchii folderów następnym krokiem jest zagłębienie się w zawartość konkretnych folderów. Wyobraź sobie, że nawigujesz do swojej Skrzynki Odbiorczej; teraz chcesz zobaczyć wszystkie wiadomości, które ona zawiera.

W tej sekcji odkryjemy, jak listować wiadomości w danym folderze przy użyciu GraphClient i Aspose.Email dla .NET.

Gdy masz folder, listowanie wiadomości w nim jest proste. GraphClient udostępnia metodę ListMessages, aby pobrać wszystkie wiadomości w folderze, które możesz następnie przetwarzać lub wyświetlać.

Oto kod, aby listować wiadomości z określonego folderu:

Console.WriteLine("Listowanie wiadomości w określonym folderze...");

// Call the client method to list messages in the selected folder
var messageInfoCollection = client.ListMessages(targetFolder.ItemId);

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

// Print out the subject lines of the messages
foreach (var messageInfo in messageInfoCollection)
{
    Console.WriteLine($"     - {messageInfo.Subject}");
}

messageInfoCollection zawiera istotne informacje o każdym e-mailu. Te informacje mogą być użyte do wyświetlania podsumowań, generowania raportów, a nawet uruchamiania powiadomień na podstawie konkretnych kryteriów.

Podsumowanie

W tym artykule zbadaliśmy, jak wykorzystać moc Microsoft Graph i biblioteki Aspose.Email dla .NET do skutecznego przetwarzania skrzynek pocztowych, nawigowania po hierarchiach folderów i listowania wiadomości w określonych folderach. Postępując zgodnie z tymi krokami, możesz budować solidne aplikacje, które płynnie współdziałają z danymi e-mail, zapewniając lepszą funkcjonalność i doświadczenia użytkowników.

Koncepcje w działaniu

Jeśli chcesz zobaczyć te koncepcje w działaniu, możesz pobrać w pełni funkcjonalny przykład działającej aplikacji. Ta aplikacja zawiera kod źródłowy opisany w tym artykule i demonstruje, jak wdrożyć te funkcje krok po kroku.

Odwiedź naszą stronę na GitHubie, aby uzyskać dostęp do przykładowej aplikacji: Aspose.Email dla .NET - Przykład GraphApp.

Przetwarzanie skrzynek pocztowych przez Microsoft Graph oferuje niespotykany dostęp do danych e-mail i możliwości zarządzania. Dzięki odpowiednim narzędziom i technikom możesz budować zaawansowane aplikacje, które dostarczają wartościowych spostrzeżeń i automatyzują złożone zadania, co ostatecznie zwiększa wydajność i satysfakcję użytkowników.

Wypróbuj za darmo

Dodatkowo Aspose.Email oferuje wszechstronną dokumentację, rozbudowaną referencję API oraz różnorodne bezpłatne narzędzia online i aplikacje, które mogą wzbogacić Twój proces deweloperski. Programiści mogą również uzyskać dostęp do bezpłatnego forum wsparcia w celu uzyskania pomocy i spostrzeżeń, a także być na bieżąco z najnowszymi wskazówkami i samouczkami przez bloga Aspose blog.

Zobacz także

• Połącz się z skrzynką pocztową Microsoft365 za pomocą nowoczesnej autoryzacji w C# .NET
• Twórz i wysyłaj wiadomości za pomocą Microsoft Graph API w C#