Erstellen von .NET-Apps mit Microsoft Graph
In diesem Tutorial erfahren Sie, wie Sie eine .NET-Konsolen-App erstellen, die die Microsoft Graph-API verwendet, um im Namen eines Benutzers auf Daten zuzugreifen.
Hinweis
Informationen zur Verwendung von Microsoft Graph für den Zugriff auf Daten mithilfe der reinen App-Authentifizierung finden Sie in diesem Tutorial zur reinen App-Authentifizierung.
In diesem Lernprogramm wird Folgendes vermittelt:
- Abrufen des angemeldeten Benutzers
- Auflisten der Posteingangsnachrichten des Benutzers
- E-Mail senden
Tipp
Alternativ zu diesem Tutorial können Sie den vollständigen Code über das Schnellstarttool herunterladen, das die App-Registrierung und -Konfiguration automatisiert. Der heruntergeladene Code funktioniert ohne Änderungen.
Sie können auch das GitHub-Repository herunterladen oder klonen und die Anweisungen in der INFODATEI befolgen, um eine Anwendung zu registrieren und das Projekt zu konfigurieren.
Voraussetzungen
Bevor Sie mit diesem Tutorial beginnen, sollte das .NET SDK auf Ihrem Entwicklungscomputer installiert sein.
Sie sollten auch über ein Microsoft-Geschäfts-, Schul- oder Unikonto mit einem Exchange Online-Postfach verfügen. Wenn Sie nicht über einen Microsoft 365-Mandanten verfügen, können Sie sich über das Microsoft 365-Entwicklerprogramm für einen mandantenfähigen Mandanten qualifizieren. Weitere Informationen finden Sie in den häufig gestellten Fragen. Alternativ können Sie sich für eine kostenlose 1-monatige Testversion registrieren oder einen Microsoft 365-Plan erwerben.
Hinweis
Dieses Tutorial wurde mit .NET SDK Version 7.0.102 geschrieben. Die Schritte in diesem Leitfaden funktionieren möglicherweise mit anderen Versionen, die jedoch nicht getestet wurden.
Registrieren der App im Portal
In dieser Übung registrieren Sie eine neue Anwendung in Azure Active Directory, um die Benutzerauthentifizierung zu aktivieren. Sie können eine Anwendung über das Microsoft Entra Admin Center oder mithilfe des Microsoft Graph PowerShell SDK registrieren.
Registrieren der Anwendung für die Benutzerauthentifizierung
In diesem Abschnitt registrieren Sie eine Anwendung, die die Benutzerauthentifizierung mithilfe des Gerätecodeflows unterstützt.
Öffnen Sie einen Browser, navigieren Sie zum Microsoft Entra Admin Center , und melden Sie sich mit einem globalen Administratorkonto an.
Wählen Sie im linken Navigationsbereich Microsoft Entra ID aus, erweitern Sie Identität, erweitern Sie Anwendungen, und wählen Sie dann App-Registrierungen aus.
Wählen Sie Neue Registrierung aus. Geben Sie einen Namen für Ihre Anwendung ein,
Graph User Auth Tutorial
z. B. .Legen Sie unterstützte Kontotypen wie gewünscht fest. Mögliche Optionen:
Option Wer kann sich anmelden? Nur Konten in diesem Organisationsverzeichnis Nur Benutzer in Ihrer Microsoft 365-Organisation Konten in einem beliebigen Organisationsverzeichnis Benutzer in einer beliebigen Microsoft 365-Organisation (Geschäfts-, Schul- oder Unikonten) Konten in einem beliebigen Organisationsverzeichnis ... und persönliche Microsoft-Konten Benutzer in jeder Microsoft 365-Organisation (Geschäfts-, Schul- oder Unikonten) und persönliche Microsoft-Konten Lassen Sie URI umleiten leer.
Wählen Sie Registrieren aus. Kopieren Sie auf der Seite Übersicht der Anwendung den Wert der Anwendungs-ID (Client-ID), und speichern Sie ihn. Sie benötigen ihn im nächsten Schritt. Wenn Sie nur Konten in diesem Organisationsverzeichnis für Unterstützte Kontotypen ausgewählt haben, kopieren Sie auch die Verzeichnis-ID (Mandant), und speichern Sie sie.
Wählen Sie unter Verwalten die Option Authentifizierung aus. Suchen Sie den Abschnitt Erweiterte Einstellungen , und ändern Sie die Umschaltfläche Öffentliche Clientflows zulassen auf Ja, und wählen Sie dann Speichern aus.
Hinweis
Beachten Sie, dass Sie keine Microsoft Graph-Berechtigungen für die App-Registrierung konfiguriert haben. Dies liegt daran, dass im Beispiel die dynamische Zustimmung verwendet wird, um bestimmte Berechtigungen für die Benutzerauthentifizierung anzufordern.
Erstellen einer .NET-Konsolen-App
Erstellen Sie zunächst ein neues .NET-Konsolenprojekt mithilfe der .NET CLI.
Öffnen Sie Ihre Befehlszeilenschnittstelle (CLI) in einem Verzeichnis, in dem Sie das Projekt erstellen möchten. Führen Sie den folgenden Befehl aus.
dotnet new console -o GraphTutorial
Nachdem das Projekt erstellt wurde, überprüfen Sie, ob es funktioniert, indem Sie das aktuelle Verzeichnis in das Verzeichnis GraphTutorial ändern und den folgenden Befehl in Ihrer CLI ausführen.
dotnet run
Wenn es funktioniert, sollte die App ausgeben
Hello, World!
.
Installieren von Abhängigkeiten
Bevor Sie mit dem Vorgang fortfahren, fügen Sie einige zusätzliche Abhängigkeiten hinzu, die Sie später verwenden werden.
- .NET-Konfigurationspakete zum Lesen der Anwendungskonfiguration aus appsettings.json.
- Azure Identity-Clientbibliothek für .NET zum Authentifizieren des Benutzers und Abrufen von Zugriffstoken.
- Microsoft Graph .NET-Clientbibliothek , um Aufrufe an Microsoft Graph zu tätigen.
Führen Sie die folgenden Befehle in Ihrer CLI aus, um die Abhängigkeiten zu installieren.
dotnet add package Microsoft.Extensions.Configuration.Binder
dotnet add package Microsoft.Extensions.Configuration.Json
dotnet add package Microsoft.Extensions.Configuration.UserSecrets
dotnet add package Azure.Identity
dotnet add package Microsoft.Graph
Laden von Anwendungseinstellungen
In diesem Abschnitt fügen Sie dem Projekt die Details Ihrer App-Registrierung hinzu.
Erstellen Sie im Verzeichnis GraphTutorial eine Datei mit dem Namen appsettings.json , und fügen Sie den folgenden Code hinzu.
{ "settings": { "clientId": "YOUR_CLIENT_ID_HERE", "tenantId": "common", "graphUserScopes": [ "user.read", "mail.read", "mail.send" ] } }
Aktualisieren Sie die Werte gemäß der folgenden Tabelle.
Einstellung Wert clientId
Die Client-ID Ihrer App-Registrierung tenantId
Wenn Sie die Option ausgewählt haben, nur Benutzern in Ihrer Organisation die Anmeldung zu gestatten, ändern Sie diesen Wert in Ihre Mandanten-ID. Übernehmen Sie andernfalls den Wert common
.Tipp
Optional können Sie diese Werte in einer separaten Datei mit dem Namen appsettings festlegen. Development.json oder im .NET-Geheimnis-Manager.
Aktualisieren Sie GraphTutorial.csproj , um appsettings.json in das Ausgabeverzeichnis zu kopieren. Fügen Sie den folgenden Code zwischen den
<Project>
Zeilen und</Project>
hinzu.<ItemGroup> <None Include="appsettings*.json"> <CopyToOutputDirectory>Always</CopyToOutputDirectory> </None> </ItemGroup>
Erstellen Sie im Verzeichnis GraphTutorial eine Datei mit dem Namen Settings.cs , und fügen Sie den folgenden Code hinzu.
using Microsoft.Extensions.Configuration; public class Settings { public string? ClientId { get; set; } public string? TenantId { get; set; } public string[]? GraphUserScopes { get; set; } public static Settings LoadSettings() { // Load settings IConfiguration config = new ConfigurationBuilder() // appsettings.json is required .AddJsonFile("appsettings.json", optional: false) // appsettings.Development.json" is optional, values override appsettings.json .AddJsonFile($"appsettings.Development.json", optional: true) // User secrets are optional, values override both JSON files .AddUserSecrets<Program>() .Build(); return config.GetRequiredSection("Settings").Get<Settings>() ?? throw new Exception("Could not load app settings. See README for configuration instructions."); } }
Entwerfen der App
In diesem Abschnitt erstellen Sie ein einfaches konsolenbasiertes Menü.
Öffnen Sie ./Program.cs , und ersetzen Sie den gesamten Inhalt durch den folgenden Code.
Console.WriteLine(".NET Graph Tutorial\n"); var settings = Settings.LoadSettings(); // Initialize Graph InitializeGraph(settings); // Greet the user by name await GreetUserAsync(); int choice = -1; while (choice != 0) { Console.WriteLine("Please choose one of the following options:"); Console.WriteLine("0. Exit"); Console.WriteLine("1. Display access token"); Console.WriteLine("2. List my inbox"); Console.WriteLine("3. Send mail"); Console.WriteLine("4. Make a Graph call"); try { choice = int.Parse(Console.ReadLine() ?? string.Empty); } catch (System.FormatException) { // Set to invalid value choice = -1; } switch(choice) { case 0: // Exit the program Console.WriteLine("Goodbye..."); break; case 1: // Display access token await DisplayAccessTokenAsync(); break; case 2: // List emails from user's inbox await ListInboxAsync(); break; case 3: // Send an email message await SendMailAsync(); break; case 4: // Run any Graph code await MakeGraphCallAsync(); break; default: Console.WriteLine("Invalid choice! Please try again."); break; } }
Fügen Sie am Ende der Datei die folgenden Platzhaltermethoden hinzu. Sie implementieren sie in späteren Schritten.
void InitializeGraph(Settings settings) { // TODO } async Task GreetUserAsync() { // TODO } async Task DisplayAccessTokenAsync() { // TODO } async Task ListInboxAsync() { // TODO } async Task SendMailAsync() { // TODO } async Task MakeGraphCallAsync() { // TODO }
Dadurch wird ein einfaches Menü implementiert und die Auswahl des Benutzers aus der Befehlszeile gelesen.
Hinzufügen der Benutzerauthentifizierung
In diesem Abschnitt erweitern Sie die Anwendung aus der vorherigen Übung, um die Authentifizierung mit Azure AD zu unterstützen. Dies ist erforderlich, um das erforderliche OAuth-Zugriffstoken zum Aufrufen von Microsoft Graph abzurufen. In diesem Schritt integrieren Sie die Azure Identity-Clientbibliothek für .NET in die Anwendung und konfigurieren die Authentifizierung für die Microsoft Graph .NET-Clientbibliothek.
Die Azure Identity-Bibliothek bietet eine Reihe von TokenCredential
Klassen, die OAuth2-Tokenflows implementieren. Die Microsoft Graph-Clientbibliothek verwendet diese Klassen, um Aufrufe von Microsoft Graph zu authentifizieren.
Konfigurieren des Graph-Clients für die Benutzerauthentifizierung
In diesem Abschnitt verwenden Sie die DeviceCodeCredential
-Klasse, um mithilfe des Gerätecodeflows ein Zugriffstoken anzufordern.
Erstellen Sie im Verzeichnis GraphTutorial eine neue Datei mit dem Namen GraphHelper.cs , und fügen Sie der Datei den folgenden Code hinzu.
using Azure.Core; using Azure.Identity; using Microsoft.Graph; using Microsoft.Graph.Models; using Microsoft.Graph.Me.SendMail; class GraphHelper { }
Fügen Sie der
GraphHelper
-Klasse den folgenden Code hinzu.// Settings object private static Settings? _settings; // User auth token credential private static DeviceCodeCredential? _deviceCodeCredential; // Client configured with user authentication private static GraphServiceClient? _userClient; public static void InitializeGraphForUserAuth(Settings settings, Func<DeviceCodeInfo, CancellationToken, Task> deviceCodePrompt) { _settings = settings; var options = new DeviceCodeCredentialOptions { ClientId = settings.ClientId, TenantId = settings.TenantId, DeviceCodeCallback = deviceCodePrompt, }; _deviceCodeCredential = new DeviceCodeCredential(options); _userClient = new GraphServiceClient(_deviceCodeCredential, settings.GraphUserScopes); }
Ersetzen Sie die leere
InitializeGraph
Funktion in Program.cs durch Folgendes.void InitializeGraph(Settings settings) { GraphHelper.InitializeGraphForUserAuth(settings, (info, cancel) => { // Display the device code message to // the user. This tells them // where to go to sign in and provides the // code to use. Console.WriteLine(info.Message); return Task.FromResult(0); }); }
Dieser Code deklariert zwei private Eigenschaften, ein DeviceCodeCredential
-Objekt und ein GraphServiceClient
-Objekt. Die InitializeGraphForUserAuth
-Funktion erstellt eine neue Instanz von DeviceCodeCredential
und verwendet diese Instanz dann, um eine neue Instanz von GraphServiceClient
zu erstellen. Jedes Mal, wenn ein API-Aufruf an Microsoft Graph über _userClient
erfolgt, werden die bereitgestellten Anmeldeinformationen verwendet, um ein Zugriffstoken abzurufen.
Testen von DeviceCodeCredential
Fügen Sie als Nächstes Code hinzu, um ein Zugriffstoken DeviceCodeCredential
von abzurufen.
Fügen Sie die folgende Funktion zur
GraphHelper
-Klasse hinzu:public static async Task<string> GetUserTokenAsync() { // Ensure credential isn't null _ = _deviceCodeCredential ?? throw new System.NullReferenceException("Graph has not been initialized for user auth"); // Ensure scopes isn't null _ = _settings?.GraphUserScopes ?? throw new System.ArgumentNullException("Argument 'scopes' cannot be null"); // Request token with given scopes var context = new TokenRequestContext(_settings.GraphUserScopes); var response = await _deviceCodeCredential.GetTokenAsync(context); return response.Token; }
Ersetzen Sie die leere
DisplayAccessTokenAsync
Funktion in Program.cs durch Folgendes.async Task DisplayAccessTokenAsync() { try { var userToken = await GraphHelper.GetUserTokenAsync(); Console.WriteLine($"User token: {userToken}"); } catch (Exception ex) { Console.WriteLine($"Error getting user access token: {ex.Message}"); } }
Erstellen Sie die App, und führen Sie sie aus. Geben Sie ein
1
, wenn Sie zur Eingabe einer Option aufgefordert werden. Die Anwendung zeigt eine URL und den Gerätecode an..NET Graph Tutorial Please choose one of the following options: 0. Exit 1. Display access token 2. List my inbox 3. Send mail 4. Make a Graph call 1 To sign in, use a web browser to open the page https://microsoft.com/devicelogin and enter the code RB2RUD56D to authenticate.
Öffnen Sie einen Browser, und navigieren Sie zu der angezeigten URL. Geben Sie den angegebenen Code ein, und melden Sie sich an.
Wichtig
Achten Sie auf vorhandene Microsoft 365-Konten, die bei Ihrem Browser angemeldet sind, wenn Sie zu
https://microsoft.com/devicelogin
navigieren. Verwenden Sie Browserfeatures wie Profile, Gastmodus oder privaten Modus, um sicherzustellen, dass Sie sich als das Konto authentifizieren, das Sie zu Testzwecken verwenden möchten.Kehren Sie nach Abschluss des Vorgangs zur Anwendung zurück, um das Zugriffstoken anzuzeigen.
Tipp
Nur zu Validierungs- und Debugzwecken können Sie Benutzerzugriffstoken (nur für Geschäfts-, Schul- oder Unikonten) decodieren, indem Sie den Onlinetokenparser von Microsoft unter verwendenhttps://jwt.ms. Dies kann nützlich sein, wenn beim Aufrufen von Microsoft Graph Tokenfehler auftreten. Beispielsweise wird überprüft, ob der
scp
Anspruch im Token die erwarteten Microsoft Graph-Berechtigungsbereiche enthält.
Benutzer abrufen
In diesem Abschnitt integrieren Sie Microsoft Graph in die Anwendung. Für diese Anwendung verwenden Sie die Microsoft Graph .NET-Clientbibliothek , um Aufrufe an Microsoft Graph zu senden.
Öffnen Sie ./GraphHelper.cs , und fügen Sie der GraphHelper-Klasse die folgende Funktion hinzu.
public static Task<User?> GetUserAsync() { // Ensure client isn't null _ = _userClient ?? throw new System.NullReferenceException("Graph has not been initialized for user auth"); return _userClient.Me.GetAsync((config) => { // Only request specific properties config.QueryParameters.Select = new[] {"displayName", "mail", "userPrincipalName" }; }); }
Ersetzen Sie die leere
GreetUserAsync
Funktion in Program.cs durch Folgendes.async Task GreetUserAsync() { try { var user = await GraphHelper.GetUserAsync(); Console.WriteLine($"Hello, {user?.DisplayName}!"); // For Work/school accounts, email is in Mail property // Personal accounts, email is in UserPrincipalName Console.WriteLine($"Email: {user?.Mail ?? user?.UserPrincipalName ?? ""}"); } catch (Exception ex) { Console.WriteLine($"Error getting user: {ex.Message}"); } }
Wenn Sie die App jetzt ausführen, werden Sie nach der Anmeldung in der App mit dem Namen begrüßt.
Hello, Megan Bowen!
Email: MeganB@contoso.com
Code erläutert
Betrachten Sie den Code in der GetUserAsync
Funktion. Es sind nur wenige Zeilen, aber es sind einige wichtige Details zu beachten.
Zugreifen auf "me"
Die Funktion verwendet den Anforderungs-Generator _userClient.Me
, der eine Anforderung an die Get-Benutzer-API erstellt. Auf diese API kann auf zwei Arten zugegriffen werden:
GET /me
GET /users/{user-id}
In diesem Fall ruft der Code den GET /me
API-Endpunkt auf. Dies ist eine Verknüpfungsmethode, um den authentifizierten Benutzer abzurufen, ohne seine Benutzer-ID zu kennen.
Hinweis
Da der GET /me
API-Endpunkt den authentifizierten Benutzer abruft, ist er nur für Apps verfügbar, die die Benutzerauthentifizierung verwenden. Reine App-Authentifizierungs-Apps können nicht auf diesen Endpunkt zugreifen.
Anfordern bestimmter Eigenschaften
Die Funktion verwendet die Select
-Methode für die Anforderung, um die benötigten Eigenschaften anzugeben. Dadurch wird dem API-Aufruf der Abfrageparameter $select hinzugefügt.
Stark typisierter Rückgabetyp
Die Funktion gibt ein Microsoft.Graph.User
Objekt zurück, das aus der JSON-Antwort der API deserialisiert wurde. Da der Code verwendet Select
, verfügen nur die angeforderten Eigenschaften über Werte im zurückgegebenen User
Objekt. Alle anderen Eigenschaften verfügen über Standardwerte.
Posteingang auflisten
In diesem Abschnitt fügen Sie die Möglichkeit hinzu, Nachrichten im E-Mail-Posteingang des Benutzers aufzulisten.
Öffnen Sie ./GraphHelper.cs , und fügen Sie der GraphHelper-Klasse die folgende Funktion hinzu.
public static Task<MessageCollectionResponse?> GetInboxAsync() { // Ensure client isn't null _ = _userClient ?? throw new System.NullReferenceException("Graph has not been initialized for user auth"); return _userClient.Me // Only messages from Inbox folder .MailFolders["Inbox"] .Messages .GetAsync((config) => { // Only request specific properties config.QueryParameters.Select = new[] { "from", "isRead", "receivedDateTime", "subject" }; // Get at most 25 results config.QueryParameters.Top = 25; // Sort by received time, newest first config.QueryParameters.Orderby = new[] { "receivedDateTime DESC" }; }); }
Ersetzen Sie die leere
ListInboxAsync
Funktion in Program.cs durch Folgendes.async Task ListInboxAsync() { try { var messagePage = await GraphHelper.GetInboxAsync(); if (messagePage?.Value == null) { Console.WriteLine("No results returned."); return; } // Output each message's details foreach (var message in messagePage.Value) { Console.WriteLine($"Message: {message.Subject ?? "NO SUBJECT"}"); Console.WriteLine($" From: {message.From?.EmailAddress?.Name}"); Console.WriteLine($" Status: {(message.IsRead!.Value ? "Read" : "Unread")}"); Console.WriteLine($" Received: {message.ReceivedDateTime?.ToLocalTime().ToString()}"); } // If NextPageRequest is not null, there are more messages // available on the server // Access the next page like: // var nextPageRequest = new MessagesRequestBuilder(messagePage.OdataNextLink, _userClient.RequestAdapter); // var nextPage = await nextPageRequest.GetAsync(); var moreAvailable = !string.IsNullOrEmpty(messagePage.OdataNextLink); Console.WriteLine($"\nMore messages available? {moreAvailable}"); } catch (Exception ex) { Console.WriteLine($"Error getting user's inbox: {ex.Message}"); } }
Führen Sie die App aus, melden Sie sich an, und wählen Sie Option 2 aus, um Ihren Posteingang aufzulisten.
Please choose one of the following options: 0. Exit 1. Display access token 2. List my inbox 3. Send mail 4. Make a Graph call 2 Message: Updates from Ask HR and other communities From: Contoso Demo on Yammer Status: Read Received: 12/30/2021 4:54:54 AM -05:00 Message: Employee Initiative Thoughts From: Patti Fernandez Status: Read Received: 12/28/2021 5:01:10 PM -05:00 Message: Voice Mail (11 seconds) From: Alex Wilber Status: Unread Received: 12/28/2021 5:00:46 PM -05:00 Message: Our Spring Blog Update From: Alex Wilber Status: Unread Received: 12/28/2021 4:49:46 PM -05:00 Message: Atlanta Flight Reservation From: Alex Wilber Status: Unread Received: 12/28/2021 4:35:42 PM -05:00 Message: Atlanta Trip Itinerary - down time From: Alex Wilber Status: Unread Received: 12/28/2021 4:22:04 PM -05:00 ... More messages available? True
Code erläutert
Betrachten Sie den Code in der GetInboxAsync
Funktion.
Zugreifen auf bekannte E-Mail-Ordner
Die Funktion verwendet den Anforderungs-Generator _userClient.Me.MailFolders["Inbox"].Messages
, der eine Anforderung an die Api zum Auflisten von Nachrichten erstellt. Da sie den Anforderungs-Generator MailFolders["Inbox"]
enthält, gibt die API nur Nachrichten im angeforderten E-Mail-Ordner zurück. Da der Posteingang in diesem Fall ein bekannter Standardordner innerhalb des Postfachs eines Benutzers ist, ist er über seinen bekannten Namen zugänglich. Auf nicht standardmäßige Ordner wird auf die gleiche Weise zugegriffen, indem der bekannte Name durch die ID-Eigenschaft des E-Mail-Ordners ersetzt wird. Ausführliche Informationen zu den verfügbaren bekannten Ordnernamen finden Sie unter mailFolder-Ressourcentyp.
Zugreifen auf eine Sammlung
Im Gegensatz zur GetUserAsync
Funktion aus dem vorherigen Abschnitt, die ein einzelnes Objekt zurückgibt, gibt diese Methode eine Auflistung von Nachrichten zurück. Die meisten APIs in Microsoft Graph, die eine Sammlung zurückgeben, geben nicht alle verfügbaren Ergebnisse in einer einzigen Antwort zurück. Stattdessen wird paging verwendet, um einen Teil der Ergebnisse zurückzugeben, während clients eine Methode zum Anfordern der nächsten "Seite" bereitstellen.
Standardseitengrößen
APIs, die Paging verwenden, implementieren eine Standardseitengröße. Für Nachrichten ist der Standardwert 10. Clients können mithilfe des abfrageparameters $top mehr (oder weniger) anfordern. In GetInboxAsync
wird dies mit der .Top(25)
-Methode erreicht.
Hinweis
Der an .Top()
übergebene Wert ist eine obere Grenze, keine explizite Zahl. Die API gibt eine Anzahl von Nachrichten bis zum angegebenen Wert zurück.
Abrufen nachfolgender Seiten
Wenn auf dem Server weitere Ergebnisse verfügbar sind, enthalten Sammlungsantworten eine @odata.nextLink
Eigenschaft mit einer API-URL für den Zugriff auf die nächste Seite. Die .NET-Clientbibliothek macht dies als Eigenschaft NextPageRequest
für Auflistungsseitenobjekte verfügbar. Wenn diese Eigenschaft ungleich NULL ist, stehen weitere Ergebnisse zur Verfügung.
Die NextPageRequest
-Eigenschaft macht eine GetAsync
Methode verfügbar, die die nächste Seite zurückgibt.
Sortieren von Sammlungen
Die -Funktion verwendet die OrderBy
-Methode für die Anforderung, um Ergebnisse anzufordern, die nach dem Zeitpunkt sortiert sind, zu dem die Nachricht empfangen wird (ReceivedDateTime
-Eigenschaft). Es enthält das DESC
Schlüsselwort, sodass kürzlich empfangene Nachrichten zuerst aufgeführt werden. Dadurch wird dem API-Aufruf der abfrageparameter $orderby hinzugefügt.
Nachrichten senden
In diesem Abschnitt fügen Sie die Möglichkeit hinzu, eine E-Mail-Nachricht als authentifizierten Benutzer zu senden.
Öffnen Sie ./GraphHelper.cs , und fügen Sie der GraphHelper-Klasse die folgende Funktion hinzu.
public static async Task SendMailAsync(string subject, string body, string recipient) { // Ensure client isn't null _ = _userClient ?? throw new System.NullReferenceException("Graph has not been initialized for user auth"); // Create a new message var message = new Message { Subject = subject, Body = new ItemBody { Content = body, ContentType = BodyType.Text }, ToRecipients = new List<Recipient> { new Recipient { EmailAddress = new EmailAddress { Address = recipient } } } }; // Send the message await _userClient.Me .SendMail .PostAsync(new SendMailPostRequestBody { Message = message }); }
Ersetzen Sie die leere
SendMailAsync
Funktion in Program.cs durch Folgendes.async Task SendMailAsync() { try { // Send mail to the signed-in user // Get the user for their email address var user = await GraphHelper.GetUserAsync(); var userEmail = user?.Mail ?? user?.UserPrincipalName; if (string.IsNullOrEmpty(userEmail)) { Console.WriteLine("Couldn't get your email address, canceling..."); return; } await GraphHelper.SendMailAsync("Testing Microsoft Graph", "Hello world!", userEmail); Console.WriteLine("Mail sent."); } catch (Exception ex) { Console.WriteLine($"Error sending mail: {ex.Message}"); } }
Führen Sie die App aus, melden Sie sich an, und wählen Sie Option 3 aus, um eine E-Mail an sich selbst zu senden.
Please choose one of the following options: 0. Exit 1. Display access token 2. List my inbox 3. Send mail 4. Make a Graph call 3 Mail sent.
Hinweis
Wenn Sie mit einem Entwicklermandanten aus dem Microsoft 365-Entwicklerprogramm testen, wird die von Ihnen gesendete E-Mail möglicherweise nicht zugestellt, und Sie erhalten möglicherweise einen Nichtzustellbarkeitsbericht. Wenden Sie sich in diesem Fall über das Microsoft 365 Admin Center an den Support.
Um zu überprüfen, ob die Nachricht empfangen wurde, wählen Sie Option 2 aus, um Ihren Posteingang aufzulisten.
Code erläutert
Betrachten Sie den Code in der SendMailAsync
Funktion.
Senden von E-Mails
Die Funktion verwendet den Anforderungs-Generator _userClient.Me.SendMail
, der eine Anforderung an die API zum Senden von E-Mails erstellt. Der Anforderungs-Generator akzeptiert ein Message
-Objekt, das die zu sendende Nachricht darstellt.
Erstellen von Objekten
Im Gegensatz zu den vorherigen Aufrufen von Microsoft Graph, die nur Daten lesen, werden mit diesem Aufruf Daten erstellt. Um dies mit der Clientbibliothek zu tun, erstellen Sie eine Instanz der -Klasse, die die Daten darstellt (in diesem Fall ), Microsoft.Graph.Message
indem Sie das new
Schlüsselwort verwenden, die gewünschten Eigenschaften festlegen und sie dann im API-Aufruf senden. Da der Aufruf Daten sendet, wird die PostAsync
-Methode anstelle von GetAsync
verwendet.
Optional: Fügen Sie Ihren eigenen Code hinzu.
In diesem Abschnitt fügen Sie der Anwendung Ihre eigenen Microsoft Graph-Funktionen hinzu. Dies kann ein Codeausschnitt aus der Microsoft Graph-Dokumentation oder graph-Explorer oder code sein, den Sie erstellt haben. Dieser Abschnitt ist optional.
Aktualisieren der App
Öffnen Sie ./GraphHelper.cs , und fügen Sie der GraphHelper-Klasse die folgende Funktion hinzu.
// This function serves as a playground for testing Graph snippets // or other code public async static Task MakeGraphCallAsync() { // INSERT YOUR CODE HERE }
Ersetzen Sie die leere
MakeGraphCallAsync
Funktion in Program.cs durch Folgendes.async Task MakeGraphCallAsync() { await GraphHelper.MakeGraphCallAsync(); }
Auswählen einer API
Suchen Sie eine API in Microsoft Graph, die Sie ausprobieren möchten. Beispiel: Die Api zum Erstellen eines Ereignisses . Sie können eines der Beispiele in der API-Dokumentation verwenden, oder Sie können eine API-Anforderung im Graph-Explorer anpassen und den generierten Codeausschnitt verwenden.
Konfigurieren von Berechtigungen
Überprüfen Sie den Abschnitt Berechtigungen der Referenzdokumentation für Die ausgewählte API, um zu sehen, welche Authentifizierungsmethoden unterstützt werden. Einige APIs unterstützen z. B. keine reinen Apps oder persönlichen Microsoft-Konten.
- Um eine API mit Benutzerauthentifizierung aufzurufen (wenn die API die (delegierte) Benutzerauthentifizierung unterstützt), fügen Sie den erforderlichen Berechtigungsbereich in appsettings.json hinzu.
- Informationen zum Aufrufen einer API mit nur app-Authentifizierung finden Sie im Tutorial zur reinen App-Authentifizierung .
Fügen Sie Ihren Code hinzu
Kopieren Sie Ihren Code in die MakeGraphCallAsync
Funktion in GraphHelper.cs. Wenn Sie einen Codeausschnitt aus der Dokumentation oder dem Graph-Explorer kopieren, müssen Sie den GraphServiceClient
_userClient
in umbenennen.
Herzlichen Glückwunsch!
Sie haben das Microsoft Graph-Tutorial für .NET abgeschlossen. Nachdem Sie nun über eine funktionierende App verfügen, die Microsoft Graph aufruft, können Sie experimentieren und neue Features hinzufügen.
- Erfahren Sie, wie Sie die reine App-Authentifizierung mit dem Microsoft Graph .NET SDK verwenden.
- Besuchen Sie die Übersicht über Microsoft Graph , um alle Daten anzuzeigen, auf die Sie mit Microsoft Graph zugreifen können.
.NET-Beispiele
Liegt ein Problem mit diesem Abschnitt vor? Wenn ja, senden Sie uns Feedback, damit wir den Abschnitt verbessern können.