Table of contents
TOC
Inhaltsverzeichnis reduzieren
Inhaltsverzeichnis erweitern
Zuletzt aktualisiert: 20.06.2018

Integration von Office 365-APIs in .NET Visual Studio-Projekte

Gilt für: Office 365

Nachdem Sie einen Office 365-Dienst zu Ihrem Projekt hinzugefügt haben, müssen Sie Code schreiben, der den Benutzer der Anwendung authentifiziert und auf dessen Office 365-Daten zugreift.

Der Authentifizierungsprozess hängt davon ab, ob Sie eine Webanwendung, wie z.B. eine MVC, oder eine native Anwendung, wie z.B. eine Windows Store-Anwendung, erstellen. Wählen Sie einen der folgenden Links, um ein Beispiel für die Erstellung einer Anwendung zu sehen, die die Office 365-APIs verwendet:

Hinweis Diese Walkthroughs verwenden die neueste Version der Office Developer Tools für Visual Studio. Wenn Sie frühere Versionen der Tools verwenden, sollten Sie auf die aktuelle Version upgraden, um sicherzustellen, dass der Code in diesen Beispielen korrekt funktioniert.

Integration von Office 365-APIs in ein MVC Visual Studio-Projekt

Das Beispiel, das wir erstellen werden, ist ein Single-Tenant MVC, der Azure AD Single Sign-on verwendet, um die Kontaktinformationen des Benutzers aus Office 365 zu authentifizieren und zu lesen. Wir werden das Office 365 Single-Tenant MVC Projekt auf GitHub als Modell verwenden.

Die Anwendung verwendet eine persistente Bibliothek, genanntActive Directory Authentication Library (ADAL) Token-Cache, welche eine Datenbank für das Caching verwendet. ADAL ermöglicht es Ihnen, Benutzer bei Active Directory (AD), in diesem Fall Azure AD, zu authentifizieren und dann Zugriffstokens zum Sichern von API-Aufrufen zu erhalten.

Um dieses Beispiel erfolgreich zu erstellen, müssen Sie die folgenden Berechtigungen für die Office 365-APIs festgelegt haben.

  • Für die Benutzer und Gruppen APIs, setzen Sie die Berechtigungen auf Enable sign-on und lesen Sie das Benutzerprofil.

  • Für die APIs Kontakte setzen Sie die Berechtigungen auf Kontakte der Benutzer lesen.

Um die Office 365-Tools zu öffnen, um sicherzustellen, dass Sie die oben genannten Berechtigungen gesetzt haben, klicken Sie in Projektmappen-Explorermit der rechten Maustaste auf das Projekt und wählen Sie Add > Connected Service.

Von dort aus besteht der Aufbau des Beispiels aus drei großen Schritten:

Konfigurieren Sie Ihr Projekt für die Authentifizierung mit Azure Active Directory.

Da das von uns erstellte Beispiel nur Office 365-Anmeldeauthentifizierung erfordert, verwenden wir OWINKatana und die Active Directory Authentication Library (ADAL).

Aber zuerst konfigurieren wir das Projekt so, dass es Secure Socket Layers (SSL) verwendet.

SSL für Ihr Projekt aktivieren

Visual Studio konfiguriert Ihr Projekt standardmäßig nicht für SSL. Wenn Sie SSL in Ihrem Projekt noch nicht aktiviert haben, sollten Sie jetzt die Office 365-Dienste mit der entsprechenden Redirect-URL aktualisieren.

Aktiviere SSL:

  1. Klicken Sie im Projektmappen-Explorerauf das Projekt.
  2. Unter Eigenschaften, setzen Sie SSL Aktiviert auf True.

    Visual Studio gibt einen Wert für die SSL URLan.

Als nächstes wollen wir die Anwendung aktualisieren, um den HTTPS-Endpunkt für die Startseite zu verwenden:

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt ChainStoreWeb, und wählen Sie Eigenschaften aus.
  2. Wählen Sie die Registerkarte Web. Setzen Sie unter Server die Projekt-URL auf den HTTPS-Endpunkt, den Visual Studio für die SSL-URLerstellt hat.

Schließlich werden wir nun die Dienste von Office 365 aktualisieren:

  1. Klicken Sie im Projektmappen-Explorermit der rechten Maustaste auf das Projekt und wählen Sie Add > Connected Service. Melden Sie sich ggf. an.

    Visual Studio meldet jetzt, dass eine oder mehrere Redirect-URLs in Ihrem Projekt nicht in Ihrem Anwendungseintrag in Azure AD vorhanden sind.

  2. Klicken Sie auf Ja, um die sichere Redirect-URL zu Ihrem Anwendungseintrag in Azure AD hinzuzufügen.

  3. Klicken Sie auf OK, um Services Managerzu beenden.

Verwalten Sie NuGet-Pakete, die für die Authentifizierung erforderlich sind.

Sie müssen die folgenden Azure AD und OWIN Katana Pakete für die Authentifizierung installieren:

Diese Pakete können auch ausgewählte NuGet-Pakete als Abhängigkeiten installieren.

Um die NuGet-Pakete herunterzuladen und zu installieren:

  1. Klicken Sie im Projektmappen-Explorermit der rechten Maustaste auf das Projekt.
  2. Wählen Sie NuGet Packages verwalten...
  3. Klicken Sie in Manage NuGet Packagesauf Online.
  4. Verwenden Sie das Suchfeld, um das gewünschte Paket zu finden.
  5. Wählen Sie das Paket aus und klicken Sie auf Installieren.
  6. In Projekte auswählen, klicken Sie auf OK.
  7. Akzeptieren Sie alle Lizenzen nach Aufforderung.

Aktualisieren Sie die Datei web.config, um die Authentifizierung zu aktivieren.

Wenn Sie Office 365-Dienste zu Ihrem Projekt hinzugefügt haben, hat Visual Studio die folgenden Eigenschaften zur Registrierung Ihrer Anwendung in Azure AD und zur Datei web.config in Ihrer Lösung hinzugefügt:

<add key="ida:ClientId" value="app-azure-ad-client-id" />
<add key="ida:ClientSecret" value="app-azure-ad-password" />
<add key="ida:TenantId" value="azure-tenant-where-app-is-registered" />
<add key="ida:AADInstance" value="https://login.microsoftonline.com/" 

Erstellen einer Datenbank zur Verwaltung von ADAL-Authentifizierungstoken

Als nächstes fügen wir dem Projekt eine Datenbank hinzu, die als unser ADAL-Token-Cache dient.

Weitere Informationen zum ADAL-Token-Cache finden Sie unter Der neue Token-Cache in ADAL v2.

Um die Datenbank hinzuzufügen, die als ADAL-Token-Cache fungiert:

  1. Klicken Sie im Projektmappen-Explorer, mit der rechten Maustaste auf den OrdnerApp_Data Ordner und wählen Sie dannHinzufügen > Neues Objekt...
  2. Stellen Sie sicher, dass Daten ausgewählt ist und wählen Sie dann SQL Server Database. Benennen Sie die Datenbank ADALTokenCacheDb und klicken Sie auf Add.

Stellen Sie sicher, dass die Datenbankverbindung zum Projekt web.config hinzugefügt wurde:

  1. Doppelklicken Sie in Projektmappen-Explorerauf web.config.
  2. Stellen Sie sicher, dass nach dem Abschnitt AppSettings der Datei web.config der folgende Abschnitt hinzugefügt wurde. Wenn er nicht da ist, fügen Sie hinzu:
<connectionStrings>
    <add name="DefaultConnection"
     connectionString="Data Source=(LocalDB)\v11.0;AttachDbFilename=|DataDirectory|\ADALTokenCacheDb.mdf;Integrated Security=True" providerName="System.Data.SqlClient" />
</connectionStrings>
  1. Speichern Sie die Datei.

Kopieren von Dateien, die für die Authentifizierung benötigt werden

Als nächstes importieren wir einige Dateien aus dem Office 365 Single-Tenant MVC Projekt GitHub Projekt. Wir werden erklären, wofür jede Datei verwendet wird.

Um Dateien aus dem GitHub-Projekt zu kopieren:

  1. Navigieren Sie in einem Browser zu der Datei, die Sie kopieren möchten. (Die Dateien sind unten aufgelistet).
  2. Klicken Sie mit der rechten Maustaste auf die Schaltfläche Raw und wählen Sie Ziel speichern unter...
  3. Speichern Sie die Datei auf dem Computer.
  4. Klicken Sie in Visual Studio im Projektmappen-Explorer unter dem Projektknoten mit der rechten Maustaste auf den angegebenen Ordner wie unten beschrieben und wählen Sie Add > Vorhandenes Objekt...
  5. Wählen Sie die Datei aus, von der Sie sie auf Ihrem Computer gespeichert haben.

Kopieren Sie die folgenden Dateien in den Ordner Modelle im Projekt. Diese Klassen zeigen, wie ein persistenter ADAL-Token-Cache aufgebaut und zum Speichern von Token verwendet werden kann.

Erstellen Sie einen neuen Ordner, Utils.

  1. ImProjektmappen-Explorer, klicken Sie rechts auf Ihr Projekt und wählen Sie Himzufügen > Neuer Ordner.
  2. Benennen Sie den Ordner Utils.

Kopieren Sie die folgende Datei hinein. Diese Helper-Klasse enthält Member-Variablen, die die Werte aus der web.config-Datei Ihres Projekts lesen, die Sie benötigen, um das ADAL-Authentifizierungsobjekt beim Start zu erstellen.

Schließlich kopieren Sie die Datei _LoginPartial.cshtml in den Ordner Views > Shared Ihres Projekts.

Authentifizierung mit Azure Active Directory

Nun, da wir das Projekt für die Authentifizierung konfiguriert haben, können wir tatsächlich die Funktionalität hinzufügen, die die Authentifizierung mit Azure AD handhabt.

Azure AD Single Sign-On konfigurieren

Als nächstes müssen wir dem Projekt eine OWIN-Startup-Klasse hinzufügen, um die Authentifizierung tatsächlich durchführen zu können. Um die OWIN-Startup-Klasse hinzuzufügen:

  1. Klicken Sie im Solution-Explorer mit der rechten Maustaste auf das > -Projekt, und wählen Sie Hinzufügen | Neues Element aus...
  2. In Neues Element hinzufügen, unter Web, wählen Sie Allgemein, dann OWIN Startup class.
  3. Als Name, geben Sie Startup ein.
  4. Klicken Sie auf Hinzufügen.

Eine neue Start-up-Klasse wird Ihrem Projekt hinzugefügt.

Als nächstes fügen wir den Code für die Authentifizierung hinzu:

  1. Ersetzen Sie die Namensraum Referenzen in der Datei durch die folgenden:
    using Microsoft.IdentityModel.Clients.ActiveDirectory;
    using Microsoft.Owin.Security;
    using Microsoft.Owin.Security.Cookies;
    using Microsoft.Owin.Security.OpenIdConnect;
    using O365_WebApp_SingleTenant.Models;
    using O365_WebApp_SingleTenant.Utils;
    using Owin;
    using System;
    using System.IdentityModel.Claims;
    using System.Threading.Tasks;
    using System.Web;
    using Microsoft.Owin;
  1. Fügen Sie die folgende Methode, ConfigureAuth, zur Startup-Klasse hinzu.
    public void ConfigureAuth(IAppBuilder app)
    {
        app.SetDefaultSignInAsAuthenticationType(CookieAuthenticationDefaults.AuthenticationType);

        app.UseCookieAuthentication(new CookieAuthenticationOptions());

        app.UseOpenIdConnectAuthentication(
            new OpenIdConnectAuthenticationOptions
            {
                ClientId = SettingsHelper.ClientId,
                Authority = SettingsHelper.Authority,

                Notifications = new OpenIdConnectAuthenticationNotifications()
                {                       
                    // If there is a code in the OpenID Connect response, redeem it for an access token and refresh token, and store those away.
                    AuthorizationCodeReceived = (context) =>
                    {
                        var code = context.Code;
                        ClientCredential credential = new ClientCredential(SettingsHelper.ClientId, SettingsHelper.AppKey);
                        String signInUserId = context.AuthenticationTicket.Identity.FindFirst(ClaimTypes.NameIdentifier).Value;

                        AuthenticationContext authContext = new AuthenticationContext(SettingsHelper.Authority, new ADALTokenCache(signInUserId));
                        AuthenticationResult result = authContext.AcquireTokenByAuthorizationCode(code, new Uri(HttpContext.Current.Request.Url.GetLeftPart(UriPartial.Path)), credential, SettingsHelper.AADGraphResourceId);

                        return Task.FromResult(0);
                    },
                    RedirectToIdentityProvider = (context) =>
                    {
                        // This ensures that the address used for sign in and sign out is picked up dynamically from the request
                        // this allows you to deploy your app (to Azure Web Sites, for example)without having to change settings
                        // Remember that the base URL of the address used here must be provisioned in Azure AD beforehand.
                        string appBaseUrl = context.Request.Scheme + "://" + context.Request.Host + context.Request.PathBase;
                        context.ProtocolMessage.RedirectUri = appBaseUrl + "/";
                        context.ProtocolMessage.PostLogoutRedirectUri = appBaseUrl;

                        return Task.FromResult(0);
                    },
                    AuthenticationFailed = (context) =>
                    {
                        // Suppress the exception if you don't want to see the error
                        context.HandleResponse();
                        return Task.FromResult(0);
                    }
                }

            });
    }
  1. Fügen Sie Code zur Methode Startup.Configuration hinzu, die die Methode ConfigureAuth aufruft.
    public void Configuration(IAppBuilder app)
    {
        ConfigureAuth(app);
    }

Hinzufügen eines Controllers zur An- und Abmeldung von Office 365

Fügen Sie einen Account Controller hinzu, um die An- und Abmeldung zu verwalten:

  1. Im Projektmappen-Explorer klicken Sie mit der rechten Maustaste auf den Ordner Controller und wählen Sie Add > Controller...
  2. Wählen Sie MVC 5 Controller - Empty und klicken Sie auf Add.
  3. Geben Sie unter Controller-Name AccountControllerein und klicken Sie auf Add.
  4. Ersetzen Sie die Namensraumreferenzen in der Datei durch die folgenden:
    using Microsoft.IdentityModel.Clients.ActiveDirectory;
    using Microsoft.Owin.Security;
    using Microsoft.Owin.Security.Cookies;
    using Microsoft.Owin.Security.OpenIdConnect;
    using O365_WebApp_SingleTenant.Utils;
    using System.Security.Claims;
    using System.Web;
    using System.Web.Mvc;
  1. Löschen Sie die Methode Index().
  2. Fügen Sie die folgenden Methoden zur AccountController-Klasse hinzu, um die An- und Abmeldung zu behandeln.
    public void SignIn()
    {
        if (!Request.IsAuthenticated)
        {
            HttpContext.GetOwinContext().Authentication.Challenge(new AuthenticationProperties { RedirectUri = "/" }, OpenIdConnectAuthenticationDefaults.AuthenticationType);
        }
    }
    public void SignOut()
    {
        string callbackUrl = Url.Action("SignOutCallback", "Account", routeValues: null, protocol: Request.Url.Scheme);

        HttpContext.GetOwinContext().Authentication.SignOut(
            new AuthenticationProperties { RedirectUri = callbackUrl },
            OpenIdConnectAuthenticationDefaults.AuthenticationType, CookieAuthenticationDefaults.AuthenticationType);
    }

    public ActionResult SignOutCallback()
    {
        if (Request.IsAuthenticated)
        {
            // Redirect to home page if the user is authenticated.
            return RedirectToAction("Index", "Home");
        }

        return View();
    }

Zugriff auf Office 365-APIs

Jetzt sind wir bereit, den Code hinzuzufügen, der auf die Office 365-Daten des Benutzers zugreift.

Erstellen des Modells für die Kontaktinformationsansicht

Zuerst müssen wir die Klasse erstellen, auf der die Ansicht "Kontakte" basiert:

  1. Klicken Sie in Projektmappen-Explorermit der rechten Maustaste auf den Ordner Modelle und wählen Sie Hinzufügen > Klasse....
  2. Klicken Sie auf Klasse, geben Sie MeinKontakt als Namen ein und klicken Sie Hinzufügen.
  3. Fügen Sie in der Klasse die folgende Zeile Code hinzu.
    public class MyContact
    {
        public string Name { get; set; }
    }
  1. Speichern Sie die Datei.

Hinzufügen eines Controllers für Kontaktinformationen

Als nächstes fügen Sie einen Controller für die Kontaktinformationen der Benutzer hinzu:

  1. Im Projektmappen-Explorer klicken Sie mit der rechten Maustaste auf den Ordner Controller und wählen Sie Add > Controller...
  2. Wählen Sie MVC 5 Controller - Empty und klicken Sie auf Add.
  3. Geben Sie unter Controllername ContactsControllerein und klicken Sie auf Add.

    Visual Studio fügt dem Projekt einen neuen leeren Controller hinzu.

  4. Ersetzen Sie die Namensraumreferenzen in der Datei durch die folgenden:

     using Microsoft.IdentityModel.Clients.ActiveDirectory;
     using Microsoft.Office365.Discovery;
     using Microsoft.Office365.OutlookServices;
     using O365_WebApp_SingleTenant.Models;
     using O365_WebApp_SingleTenant.Utils;
     using System.Collections.Generic;
     using System.Security.Claims;
     using System.Threading.Tasks;
     using System.Web.Mvc;
    
Stellen Sie sicher, dass Sie eine Namensraum Referenz für den Modell-Namensraum Ihres Projekts hinzufügen:


        using [projectname].Models;
  1. Fügen Sie das Attribut[Authorize] zur ContactsController-Klasse hinzu.

Das Attribut [Authorize] erfordert, dass der Benutzer authentifiziert wird, bevor er auf diesen Controller zugreifen kann.

    [Authorize]
    public class ContactsController : Controller
  1. Ändern Sie die Methode Index() auf asynchron.
    public async Task<ActionResult> Index()
  1. Fügen Sie den folgenden Code zur Index() Methode hinzu.

Dieser Code erstellt den Authentifizierungskontext unter Verwendung der angemeldeten Office 365-Benutzer-ID und der Berechtigung für Ihr Office 365-Mietverhältnis.

        List<MyContact> myContacts = new List<MyContact>();

        var signInUserId = ClaimsPrincipal.Current.FindFirst(ClaimTypes.NameIdentifier).Value;
        var userObjectId = ClaimsPrincipal.Current.FindFirst("http://schemas.microsoft.com/identity/claims/objectidentifier").Value;

        AuthenticationContext authContext = new AuthenticationContext(SettingsHelper.Authority, new ADALTokenCache(signInUserId));
  1. Fügen Sie einen try-catch Block direkt unter dem obigen Code in der Index() Methode hinzu.
        try
        {

        }
        catch (AdalException exception)
        {
            //handle token acquisition failure
            if (exception.ErrorCode == AdalError.FailedToAcquireTokenSilently)
            {
                authContext.TokenCache.Clear();

                //handle token acquisition failure
            }
        }

        return View(myContacts);
  1. Fügen Sie im try Block des obigen Codes den folgenden Code zur Index() Methode hinzu.

Dieser Code versucht, ein Zugriffstoken für den Discovery Service zu erhalten, indem er die Client-ID und das Anwendungskennwort sowie die Anmeldeinformationen des Benutzers übergibt. Da das Benutzerauthentifizierungstoken zwischengespeichert wurde, ist der Controller in der Lage, das erforderliche Zugriffstoken im Hintergrund zu erwerben, ohne den Benutzer erneut nach seinen Zugangsdaten fragen zu müssen.

Mit dem Zugriffstoken kann die Anwendung ein Discovery Service-Client-Objekt erstellen und das Discovery-Client-Objekt verwenden, um den Ressourcen-Endpunkt für die Office 365-Dienstkontakte-APIs zu bestimmen.

            DiscoveryClient discClient = new DiscoveryClient(SettingsHelper.DiscoveryServiceEndpointUri,
                async () =>
                {
                    var authResult = await authContext.AcquireTokenSilentAsync(SettingsHelper.DiscoveryServiceResourceId, new ClientCredential(SettingsHelper.ClientId, SettingsHelper.AppKey), new UserIdentifier(userObjectId, UserIdentifierType.UniqueId));

                    return authResult.AccessToken;
                });

            var dcr = await discClient.DiscoverCapabilityAsync("Contacts");
  1. Schließlich, direkt unter dem obigen Code im try Block, fügen Sie den folgenden Code zur Index() Methode hinzu.

Dieser Code kontaktiert den Ressourcen-Endpunkt für den Office 365-Dienst Contacts-APIs, wobei die Anwendung und die Benutzeranmeldeinformationen ebenfalls stillschweigend übergeben werden, um ein Zugriffstoken für den Outlook-Dienst zu erhalten.

Nach Erhalt des Zugriffstokens kann der Code ein Outlook-Client-Objekt initialisieren. Der Code verwendet dann die Eigenschaft Me des Outlook-Client-Objekts, um Kontaktinformationen für diesen Benutzer abzurufen.

Schließlich liest der Controller die Liste der Benutzerkontakte durch und gibt eine Ansicht mit ihren Anzeigenamen zurück.

            OutlookServicesClient exClient = new OutlookServicesClient(dcr.ServiceEndpointUri,
                async () =>
                {
                    var authResult = await authContext.AcquireTokenSilentAsync(dcr.ServiceResourceId, new ClientCredential(SettingsHelper.ClientId, SettingsHelper.AppKey), new UserIdentifier(userObjectId, UserIdentifierType.UniqueId));

                    return authResult.AccessToken;
                });

            var contactsResult = await exClient.Me.Contacts.ExecuteAsync();

            do
            {
                var contacts = contactsResult.CurrentPage;
                foreach (var contact in contacts)
                {
                    myContacts.Add(new MyContact { Name = contact.DisplayName });
                }

                contactsResult = await contactsResult.GetNextPageAsync();

            } while (contactsResult != null);

Die abgeschlossene Index()-Methode sollte nun wie folgt lauten:

    public async Task<ActionResult> Index()
    {
        List<MyContact> myContacts = new List<MyContact>();

        var signInUserId = ClaimsPrincipal.Current.FindFirst(ClaimTypes.NameIdentifier).Value;
        var userObjectId = ClaimsPrincipal.Current.FindFirst("http://schemas.microsoft.com/identity/claims/objectidentifier").Value;

        AuthenticationContext authContext = new AuthenticationContext(SettingsHelper.Authority, new ADALTokenCache(signInUserId));

        try
        {
            DiscoveryClient discClient = new DiscoveryClient(SettingsHelper.DiscoveryServiceEndpointUri,
                async () =>
                {
                    var authResult = await authContext.AcquireTokenSilentAsync(SettingsHelper.DiscoveryServiceResourceId, new ClientCredential(SettingsHelper.ClientId, SettingsHelper.AppKey), new UserIdentifier(userObjectId, UserIdentifierType.UniqueId));

                    return authResult.AccessToken;
                });

            var dcr = await discClient.DiscoverCapabilityAsync("Contacts");                

            OutlookServicesClient exClient = new OutlookServicesClient(dcr.ServiceEndpointUri,
                async () =>
                {
                    var authResult = await authContext.AcquireTokenSilentAsync(dcr.ServiceResourceId, new ClientCredential(SettingsHelper.ClientId, SettingsHelper.AppKey), new UserIdentifier(userObjectId, UserIdentifierType.UniqueId));

                    return authResult.AccessToken;
                });

            var contactsResult = await exClient.Me.Contacts.ExecuteAsync();

            do
            {
                var contacts = contactsResult.CurrentPage;
                foreach (var contact in contacts)
                {
                    myContacts.Add(new MyContact { Name = contact.DisplayName });
                }

                contactsResult = await contactsResult.GetNextPageAsync();

            } while (contactsResult != null);
        }
        catch (AdalException exception)
        {
            //handle token acquisition failure
            if (exception.ErrorCode == AdalError.FailedToAcquireTokenSilently)
            {
                authContext.TokenCache.Clear();

                //handle token acquisition failure
            }
        }

        return View(myContacts);
    }

Erstellen der Ansicht für die Kontaktdaten

Als nächstes können wir die Ansicht für die Kontaktinformationen des Benutzers erstellen. Wir tun dies, indem wir die Ansicht auf die MeinKontakt -Klasse stützen, die wir zuvor erstellt haben.

  1. Klicken Sie im Projektmappen-Explorermit der rechten Maustaste auf den Ordner Contacts und wählen Sie Add > View.
  2. Definieren Sie im Dialogfenster Add View die neue Ansicht:
    • AlsName der Ansicht, geben Sie Indexein.
    • Unter Templatewählen Sie Liste.
    • UnterModellklassewählen Sie MeinKontakt aus.
    • Klicken Sie auf Hinzufügen.
  1. Im Projektmappen-Explorer, im Ordner Shared doppelklicken Sie auf die Datei _Layout.cshtml.

  2. Fügen Sie einen Aktionslink für die MeineKontakte-Seite hinzu und injizieren Sie die partielle Klasse für die Benutzeranmeldung. Aktualisieren Sie das HTML der Navigationsleiste aus dem, was automatisch generiert wird:

         <div class="navbar-collapse collapse">
             <ul class="nav navbar-nav">
                 <li>@Html.ActionLink("Home", "Index", "Home")</li>
                 <li>@Html.ActionLink("About", "About", "Home")</li>
                 <li>@Html.ActionLink("Contact", "Contact", "Home")</li>
             </ul>
         </div>
    

Um einen Aktionslink für die MyContacts-Seite hinzuzufügen und die partielle Klasse für die Benutzeranmeldung einzufügen:

        <div class="navbar-collapse collapse">
            <ul class="nav navbar-nav">
                <li>@Html.ActionLink("Home", "Index", "Home")</li>
                <li>@Html.ActionLink("About", "About", "Home")</li>
                <li>@Html.ActionLink("Contact", "Contact", "Home")</li>
                <li>@Html.ActionLink("My Contacts", "Index", "Contacts")</li>
            </ul>
            @Html.Partial("_LoginPartial")
        </div>

Debuggen Sie Ihre Anwendung

Sie sind nun bereit, die Lösung auszuführen. Drücken Sie F5, um Ihre Webanwendung zu debuggen.

Wenn es sich um eine neue Entwicklungsumgebung handelt, werden Sie möglicherweise von Visual Studio aufgefordert, das IIS-SSL-Zertifikat zu konfigurieren. Klicken Sie zweimal auf Ja, um fortzufahren.

  1. Visual Studio startet die Webanwendung in dem Browser, den Sie in Visual Studio.

  2. Klicken Sie auf Anmeldung in der oberen rechten Ecke der Seite und melden Sie sich bei Ihrem Office 365-Mieter an, bei dem Sie Ihre Webanwendung registriert haben.

    Da sich nur Benutzer Ihres Unternehmens bei einer einzigen Mieteranwendung anmelden dürfen, ist keine Zustimmung erforderlich. Wenn Ihre Anwendung mandantenfähig war, würde Azure AD eine Einwilligungsseite anzeigen, auf der die angeforderten Berechtigungen aufgelistet sind, damit Sie der Anwendung diese Berechtigungen erteilen können.

  3. Sobald Sie angemeldet sind, sollten Sie Ihre E-Mail-Adresse und Sign out in der Navigationsleiste oben auf der Startseite sehen.

  4. Klicken Sie auf Meine Kontakte

    Die Seite Meine Kontakte zeigt die Namen aller Exchange-Kontakte Ihres Mieters an.

Sie haben jetzt ein Web-Anwendungsprojekt, das Sie anpassen und Office 365-APIs integrieren können.

Nächste Schritte

Integration von Office 365-APIs in ein Windows Visual Studio-Projekt

Ein Beispiel für die Integration der Office 365 APIs in eine native Client-Anwendung, wie z.B. eine Windows Store oder Phone App, finden Sie unter Office 365 Windows app project auf GitHub. Das Projekt ruft eine Liste der Dateien des Benutzers ab.

Die Klasse AuthenticationHelper.cs enthält den Code zur Authentifizierung und zum Erwerb von Token von Azure AD für Office 365-Ressourcen. Im Beispiel erwerben wir ein Token für die Ressource Meine Dateien.

Dies geschieht in der Methode GetAccessToken: Um Token zu erwerben, fragen wir zunächst Office 365 Discovery Service ab, um die Fähigkeiten der App zu ermitteln. Während wir die Anwendung so konfiguriert haben, dass sie die Berechtigungen für "Meine Dateien" anfordert, gibt der Office 365-Discovery-Dienst Informationen über die Funktion "Meine Dateien" zurück, z. B. die Ressourcen-ID und die Endpunkt-URI. Mit diesen erwerben wir dann ein Zugriffstoken für die Ressource Meine Dateien.

Speicherung der letzten Mieter-ID

Da es sich bei den Geräteanwendungen standardmäßig um mandantenfähige Anwendungen handelt, weiß die App zunächst nicht, welcher Benutzer von welchem Mieter sich bei der App anmeldet, bis der Benutzer sich erfolgreich anmeldet und die App zustimmt.

Beachten Sie, dass mandantenfähige Anwendungen es externen Office 365-Benutzern ermöglichen, sich anzumelden und die Anwendung zu verwenden. Wenn die Anwendung im Windows Store veröffentlicht wird, können Benutzer die Anwendung herunterladen, sich bei ihren Office 365-Mietern anmelden und die Anwendung verwenden. Azure AD registriert die Windows-Anwendung im Namen des Benutzers beim jeweiligen Mieter des angemeldeten Benutzers.

Sobald der Benutzer zustimmt, kann die App dann die angemeldete Mieter-ID erhalten, die sie in den App-Einstellungen speichert. Mit dieser Mieter-ID kann die App dann den Authentifizierungskontext initialisieren, wenn der Benutzer die App das nächste Mal öffnet oder eine Anfrage stellt. Dadurch entfällt die Notwendigkeit, dass der Benutzer bei jeder Anfrage seine Einwilligung erteilt; er braucht nur einmal, wenn er zum ersten Mal auf die App zugreift. Dies gilt bis zum Ablauf des Zugriffstokens.

Nächste Schritte

Nachdem Sie auf die Office 365-APIs zugegriffen haben, können Sie mit den über die APIs verfügbaren Benutzerressourcen arbeiten. Weitere Informationen und Codeschnipsel, die zeigen, wie allgemeine Aufgaben mit den von Visual Studio bereitgestellten Client-Bibliotheken ausgeführt werden, finden Sie unter:

Zusätzliche Ressourcen

Codebeispiele

Visual Studio-Entwicklung

Referenz

© 2018 Microsoft