Microsoft Graph för att hantera mailboxes i C#

Integrationen av Microsoft Graph API och Aspose.Email för .NET med en e-postapplikation gör det möjligt för utvecklare att enkelt få åtkomst till och manipulera mailboxdata, utföra operationer som att hämta meddelanden, hämta mappstrukturer och spara e-post i olika format. I denna artikel kommer vi att utforska hur man utnyttjar denna kraftfulla kombination för att bearbeta och hantera mailboxes.

Microsoft Graph Presentation

Microsoft Graph är en omfattande API-plattform som tillhandahålls av Microsoft och erbjuder en enhetlig slutpunkt för att få åtkomst till ett brett utbud av Microsoft-tjänster och data. Det fungerar som en port till den stora mängd data som finns tillgänglig i Microsoft 365, inklusive Outlook-mailboxar, kalendrar, kontakter, OneDrive, Teams och mer.

Med Microsoft Graph kan utvecklare bygga applikationer som sömlöst interagerar med användardata och insikter över Microsofts molnekosystem. Detta uppnås genom RESTful API:er och SDK:er som tillhandahåller medel för att autentisera, auktorisera och fråga data med lätthet.

Om Aspose.Email för .NET-biblioteket

Aspose.Email för .NET är ett funktionsrikt bibliotek som gör det möjligt för utvecklare att arbeta med e-postfiler och protokoll i sina .NET-applikationer. Det tillhandahåller en robust uppsättning API:er för att skapa, manipulera och konvertera e-postmeddelanden i olika format, såsom MSG, EML och MBOX. Dessutom stöder biblioteket e-postprotokoll som SMTP, POP3 och IMAP, vilket möjliggör mångsidig e-posthantering.

I denna guide kommer vi att använda Aspose.Email för att interagera med Microsoft Graph, bearbeta mailboxdata programmässigt. Med GraphClient från Aspose.Email kan vi effektivt utföra mailboxoperationer genom att autentisera med Microsoft Graph.

För att börja använda biblioteket behöver du integrera det i ditt projekt. Det enklaste sättet att få Aspose.Email för .NET är genom NuGet Package Manager:

  • Öppna ditt projekt i Visual Studio.
  • Navigera till Verktyg > NuGet Package Manager > Hantera NuGet-paket för lösning.
  • Sök efter Aspose.Email.
  • Välj paketet och klicka på Installera.

Alternativt kan du använda Package Manager Console:

Install-Package Aspose.Email

Du kan också ladda ner den senaste versionen av API:et direkt från Aspose webbplats.

Konfigurera din app på Azure Portal

Innan vi dyker ner i koden är det avgörande att konfigurera din applikation inom Azure-portalen för att möjliggöra Microsoft Graph-åtkomst. Följ bara dessa steg:

  1. Skapa en Azure Active Directory (AAD) Applikation:

    • Navigera till Azure Portal.
    • Gå till Azure Active Directory > Appregistreringar.
    • Klicka på Ny registrering för att skapa en ny applikation.
    • Ange ett namn och ställ in omdirigerings-URI om det behövs.
    • Klicka på Registrera för att slutföra processen.

  2. Ställ in API-behörigheter:

    • I din registrerade app, navigera till API-behörigheter.
    • Klicka på Lägg till en behörighet > Microsoft Graph.
    • Välj Applikationsbehörigheter för server-till-server-samtal.
    • Välj nödvändiga behörigheter som Mail.Read, Mail.ReadWrite, User.Read, etc.
    • Klicka på Lägg till behörigheter för att tillämpa.

  3. Skapa en Klienthemlighet:

    • Gå till Certifikat och hemligheter i din app.
    • Klicka på Ny klienthemlighet och ange en beskrivning.
    • Ställ in en utgångsperiod, klicka sedan på Lägg till.
    • Notera det genererade klienthemlighetsvärdet, eftersom du kommer att behöva det senare.

  4. Samla in konfigurationsvärden:

    • Skaffa Tenant ID, Client ID och Client Secret från din apps översiktssida och hemlighetssektion.
    • Du kommer att använda dessa värden för att autentisera och interagera med Microsoft Graph.

När din applikation är konfigurerad är du redo att gå vidare med utvecklingsuppgifterna.

Skaffa åtkomsttoken och initiera GraphClient

Innan vi dyker ner i mailboxoperationer behöver vi låsa upp dörren till Microsoft Graphs stora ekosystem av data och tjänster. Denna åtkomst beviljas genom en OAuth 2.0-åtkomsttoken - en digital nyckel som auktoriserar din applikation att interagera med Microsoft Graph å användarens eller tjänstens vägnar. Tänk på det som en säker pass som ger dig tillgång till ett helt universum av möjligheter, från att hämta e-post till att hantera kontakter och mer.

Steg 1: Ställ in en konfigurationsfil

Det första steget för att förvärva token är att ställa in en konfigurationsfil som lagrar viktiga detaljer som din applikations Tenant ID, Client ID och Client Secret. Dessa värden är din applikations autentiseringsuppgifter och fungerar som identifierare vid kommunikation med Microsoft-servrar.

Här är hur din JSON-konfiguration kan se ut:

{
    "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"
}

Steg 2: Mappa JSON-konfiguration till ett C#-objekt

Nu, låt oss omvandla denna konfiguration till ett C#-objekt som vår applikation kan använda. Vi kommer att läsa JSON-filen och mappa dess innehåll till en AuthenticationConfig-klass, vilket säkerställer att vår applikation vet var den hittar den kritiska information den behöver.

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

Steg 3: Skaffa åtkomsttoken

Med vår konfiguration på plats är det dags att skaffa åtkomsttoken. Vi kommer att implementera en GraphTokenProvider-klass som hanterar autentiseringsprocessen med hjälp av Microsoft Authentication Library (MSAL). Denna klass tar hand om det tunga arbetet - att kommunicera med Microsoft Graph för att få den token som ger vår applikation makt.

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

        // I minnes token-cacher (App och User-cacher)
        _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 förvärvad från {result.AuthenticationResultMetadata.TokenSource} {Environment.NewLine}");
        }
        catch (MsalServiceException ex)
        {
            Console.WriteLine($"Fel vid förvärv av token:{Environment.NewLine}{ex}{Environment.NewLine}");
            result = null;
        }

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

Steg 4: Initiera GraphClient

Till sist initierar vi GraphClient med den token vi har förvärvat. GraphClient fungerar som vår bro till Microsoft Graph, vilket gör att vi kan interagera med användarens mailboxes sömlöst.

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;

Hämta en mappstruktur och hämta mappar efter namn

När du har skaffat åtkomst till Microsoft Graph är det dags att ge dig ut på en utforskning av mailboxen. I denna sektion kommer vi att dyka ner i att hämta och navigera i mappstrukturen för en mailbox, vilket gör att du kan få åtkomst till specifika mappar efter namn.

Steg 1: Förstå mappstrukturen

Mailboxes är strukturerade hierarkiskt, precis som ett träd. Rotmappen förgrenar sig i flera undermappar, var och en med sin egen uppsättning e-postmeddelanden och potentiellt fler undermappar. Denna nestlade struktur möjliggör organiserad hantering och enkel navigering av e-post.

Låt oss definiera och använda FolderNode-klassen för att representera varje mapp i hierarkin:

// Representerar en nod i en mappstruktur,
// utökar egenskaperna hos FolderInfo och lagrar en samling av undermappar.
class FolderNode
{
    // Får FolderInfo-objektet som representerar mappinformationen.
    public FolderInfo Folder { get; }
    
    // Får samlingen av undermappar som ingår i den aktuella mappen.
    public List<FolderNode?> SubFolders { get; }

    // Initierar en ny instans av FolderNode-klassen med det angivna FolderInfo-objektet.
    public FolderNode(FolderInfo folder)
    {
        Folder = folder;
        SubFolders = new List<FolderNode?>();
    }
    
    // Skriver ut alla mappar på ett hierarkiskt sätt som börjar från den aktuella noden.
    public void PrintHierarchy()
    {
        PrintFolderNode(this, 0);
    }

    private void PrintFolderNode(FolderNode node, int indentLevel)
    {
        // Skriv ut den aktuella mappnoden med indragning
        Console.WriteLine($"{new string(' ', indentLevel * 2)}{node}");

        // Rekursivt skriv ut undermappar
        foreach (var subFolder in node.SubFolders)
        {
            PrintFolderNode(subFolder, indentLevel + 1);
        }
    }

    // Få mappens visningsnamn.
    public override string ToString()
    {
        return $"{Folder.DisplayName} ({Folder.ContentCount})";
    }
}

För att hämta hela mappstrukturen kommer vi att skapa FolderHierarchy-klassen, som utnyttjar GraphClient för att lista alla mappar rekursivt. Så här fungerar det:

static class FolderHierarchy
{
    // Hämtar alla mappar i mailboxen rekursivt och returnerar en hierarkisk samling av FolderNode-objekt.
    public static List<FolderNode> Retrieve(IGraphClient client)
    {
        // Hämta rotmappar
        var rootFolders = client.ListFolders();
        var allFolders = new List<FolderNode>();

        // Hämta undermappar rekursivt
        foreach (var folder in rootFolders)
        {
            var folderNode = new FolderNode(folder);
            RetrieveSubFolders(client, folderNode);
            allFolders.Add(folderNode);
        }

        return allFolders;
    }

    // Hämtar undermappar rekursivt och lägger till dem i föräldermappens SubFolders-egenskap.
    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);
            }
        }
    }
}

Steg 2: Hämta mappstrukturen

Genom att använda metoden FolderHierarchy.Retrieve kan du enkelt traversera mailboxen för att avslöja dess mappstruktur. Så här kan du uppnå detta:

// Hämta mappstrukturen från mailboxen
var folderNodes = FolderHierarchy.Retrieve(client);

// Skriv ut mappstrukturen i en strukturerad form
foreach (var folderNode in folderNodes)
{
    folderNode.PrintHierarchy();
}

Steg 3: Hämta mappar efter namn

När mappstrukturen har hämtats kan du snabbt lokalisera specifika mappar efter namn. Oavsett om du är intresserad av att få åtkomst till Inkorgen eller någon anpassad mapp, säkerställer denna metod att du kan hitta dem snabbt:

// Ange namnet på mappen du letar efter
string targetFolderName = "Inkorg";

// Lokalisera målmapparna efter namn
var targetFolder = folderNodes.FirstOrDefault(
    folderNode => folderNode.Folder.DisplayName.Equals(targetFolderName, StringComparison.OrdinalIgnoreCase))
    ?.Folder;

Lista meddelanden i angiven mapp

Med mappstrukturen framgångsrikt hämtad är nästa steg att dyka ner i innehållet i specifika mappar. Tänk dig att du har navigerat till din Inkorg; nu vill du se alla meddelanden den innehåller.

I denna sektion kommer vi att utforska hur man listar meddelanden inom en specifik mapp med hjälp av GraphClient och Aspose.Email för .NET.

När du väl har mappen är det enkelt att lista meddelandena i den. GraphClient tillhandahåller en ListMessages-metod för att hämta alla meddelanden i en mapp, som du sedan kan bearbeta eller visa.

Här är koden för att lista meddelanden från den angivna mappen:

Console.WriteLine("Listar meddelanden i den angivna mappen...");

// Anropa klientmetoden för att lista meddelanden i den valda mappen
var messageInfoCollection = client.ListMessages(targetFolder.ItemId);

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

// Skriv ut ämnesraderna för meddelandena
foreach (var messageInfo in messageInfoCollection)
{
    Console.WriteLine($"     - {messageInfo.Subject}");
}

messageInfoCollection innehåller viktig information om varje e-postmeddelande. Denna information kan användas för att visa sammanfattningar, generera rapporter eller till och med utlösa aviseringar baserat på specifika kriterier.

Slutsats

I denna artikel har vi utforskat hur man utnyttjar kraften i Microsoft Graph och Aspose.Email för .NET-biblioteket för att effektivt bearbeta mailboxes, navigera i mappstrukturer och lista meddelanden inom specifika mappar. Genom att följa dessa steg kan du bygga robusta applikationer som sömlöst interagerar med e-postdata och ger förbättrad funktionalitet och användarupplevelser.

Koncept i praktiken

Om du är ivrig att se dessa koncept i praktiken kan du ladda ner ett fullt fungerande exempel på en fungerande applikation. Denna applikation inkluderar källkoden som beskrivs i denna artikel och demonstrerar hur man implementerar dessa funktioner steg för steg.

Besök vårt GitHub-repo för att få tillgång till exempelapplikationen: Aspose.Email för .NET - GraphApp-exempel.

Att bearbeta mailboxes genom Microsoft Graph erbjuder oöverträffad åtkomst till e-postdata och hanteringsmöjligheter. Med rätt verktyg och tekniker kan du bygga sofistikerade applikationer som ger meningsfulla insikter och automatiserar komplexa uppgifter, vilket i slutändan förbättrar produktiviteten och användarnöjdheten.

Prova det gratis

Dessutom erbjuder Aspose.Email omfattande dokumentation, en omfattande API-referens och en mängd gratis onlineverktyg och appar för att förbättra din utvecklingsprocess. Utvecklare kan också få tillgång till ett gratis supportforum för communityhjälp och insikter, och hålla sig uppdaterade med de senaste tipsen och handledningarna genom Aspose blogg.

Se även