Freigeben über

Aktualisieren Ihres Codes von SharePoint Client Side Object Model (CSOM) auf die PnP-Bibliotheken

  • Artikel

In der klassischen SharePoint-Lösung haben Sie wahrscheinlich das clientseitige Objektmodell (CSOM) für .NET Framework als primäre Clientbibliothek für die Nutzung von SharePoint-Daten verwendet. CSOM ist seit vielen Jahren mit verschiedenen Varianten für verschiedene Versionen von SharePoint lokal und SharePoint Online verfügbar. Seit 2021 hat Microsoft eine neue Version von CSOM für SharePoint Online veröffentlicht, die auf .NET Standard 2.0 ausgerichtet ist und daher in .NET Framework 4.5+, .NET Core 2.0 und .NET 5.0/6.0/7.0/8.0 referenziert werden kann.

Wichtig

Dieser Artikel bezieht sich auf so genannte PnP-Komponenten, Beispiele und/oder Tools, bei denen es sich um Open-Source-Ressourcen handelt, die von einer aktiven Community unterstützt werden, die unterstützung für sie bereitstellt. Es gibt keine SLA für die Unterstützung von Open Source-Tools durch offizielle Microsoft-Supportkanäle. Diese Komponenten oder Beispiele verwenden jedoch standardmäßig von Microsoft unterstützte APIs und Features, die von Microsoft unterstützt werden.

Wenn Sie möchten, können Sie das folgende Video watch, anstatt den gesamten Artikel zu lesen, den Sie immer noch als eine viel detailliertere Referenz betrachten können.

Verwenden von PnP-Bibliotheken zum Vereinfachen des Entwurfs und der Implementierung von SharePoint-Lösungen

Um CSOM verwenden zu können, müssen Sie lediglich auf das NuGet-Paket Microsoft.SharePointOnline.CSOM verweisen, ein ClientContext-Objekt erstellen, die Authentifizierung konfigurieren und mit der Nutzung der SharePoint Online-Daten beginnen. Für die Authentifizierung wurde in CSOM früher der SharePointOnlineCredentials-Typ unterstützt, um die Authentifizierung mit Benutzername und Kennwort mit SharePoint Online zu nutzen. Da Microsoft jedoch zur modernen Authentifizierung gewechselt hat, wird die Authentifizierung mit Benutzername und Kennwort nicht mehr unterstützt, und Sie sollten sich auf OAuth und moderne Authentifizierung verlassen. Im folgenden Codeauszug sehen Sie ein Beispiel für die Verwendung von einfachem CSOM mit moderner Authentifizierung über die Microsoft Authentication Library (MSAL).

using Microsoft.SharePoint.Client;
using Microsoft.Identity.Client;

var clientId = "<client-Id>";
var tenantId = "<tenant-Id>";
var authority = $"https://login.microsoftonline.com/{tenantId}/";
var redirectUri = "http://localhost";

var siteUrl = new Uri("https://contoso.sharepoint.com/sites/TargetSite");

var accessToken = await AcquireTokenAsync(siteUrl);

using (var context = new ClientContext(siteUrl))
{
    context.ExecutingWebRequest += async (sender, e) =>
    {
        // Insert the access token in the request
        e.WebRequestExecutor.RequestHeaders["Authorization"] = "Bearer " + accessToken;
    };

    // Read web properties
    var web = context.Web;
    context.Load(web, w => w.Id, w => w.Title);
    await context.ExecuteQueryAsync();

    Console.WriteLine($"{web.Id} - {web.Title}");

    // Retrieve a list by title together with selected properties
    var documents = web.Lists.GetByTitle("Documents");
    context.Load(documents, d => d.Id, d => d.Title);
    await context.ExecuteQueryAsync();

    Console.WriteLine($"{documents.Id} - {documents.Title}");

    // Retrieve the top 10 items from the list
    var query = CamlQuery.CreateAllItemsQuery(10);
    var items = documents.GetItems(query);
    context.Load(items);
    await context.ExecuteQueryAsync();

    // Browse through all the items
    foreach (var i in items)
    {
        Console.WriteLine($"{i.Id} - {i["Title"]}");
    }     
}

Die AcquireTokenAsync-Methode basiert auf MSAL, um eine interaktive Authentifizierung mit Zugriffstoken-Drosselung abzurufen. Die Implementierung der -Methode ist in diesem Kontext nicht grundlegend, aber Sie finden sie im Beispiel zum CSOM, das diesem Artikel zugeordnet ist.

In den kommenden Abschnitten erfahren Sie, wie Sie die Qualität, Lesbarkeit und Wartbarkeit Ihres Codes mithilfe einiger moderner .NET-Bibliotheken wie PnP Framework und PnP Core SDK verbessern können.

Einführung in die PnP Framework-Bibliothek

Die PnP Framework-Bibliothek (veröffentlicht als Version 1.0 am Januar 2021) ist die Weiterentwicklung von CSOM und einer alten Bibliothek namens PnP Sites Core (jetzt eingestellt und archiviert). Die PnP Framework-Bibliothek ist auf .NET Standard 2.0 und .NET 5.0/6.0/7.0 ausgerichtet, sodass Sie sie auf jeder Plattform (Windows, Linux, MacOS) und in jedem cloudbasierten Dienst wie Azure-App Services, Azure Functions, Containern usw. verwenden können.

Diese Bibliothek unterstützt standardmäßig nur SharePoint Online (SPO). Wenn Sie eine moderne Lösung für SharePoint Online mit .NET entwickeln und einen CSOM-ähnlichen Codierungsstil verwenden möchten, sollten Sie unbedingt das NuGet-Paket PnP.Framework installieren und verwenden.

Aus funktionaler Sicht besteht das PnP-Framework aus einer Reihe von Erweiterungen, die auf CSOM basieren, es ist plattformübergreifend und verwendet das neue clientseitige Objektmodell (CSOM) von SPO für .NET Standard. Es ist hauptsächlich auf die moderne Authentifizierung mit OAuth 2.0 ausgerichtet, aber es gibt weiterhin Unterstützung für den reinen App-Modus in ACS für "bereits vorhandene" Apps.

Standardmäßig verwendet die PnP Framework-Bibliothek eine mehrinstanzenfähige Azure Active Directory-Anwendung namens PnP-Verwaltungsshell, die Sie in Ihrem Mandanten mit der folgenden PnP PowerShell-Syntax registrieren sollten.

Register-PnPManagementShellAccess

Dadurch wird ein Anmeldeflow gestartet, in dem Sie aufgefordert werden, der Anwendung zuzustimmen. Beachten Sie, dass nur einmal pro Mandant erforderlich ist. Sie müssen über die entsprechenden Zugriffsrechte verfügen, um Anwendungen in Azure AD zustimmen zu können.

In diesem Artikel verlassen Sie sich jedoch auf die moderne Authentifizierung mit einer benutzerdefinierten AAD-Anwendung, die Sie für die Desktopauthentifizierung mit http://localhost als unterstützten Umleitungs-URI registrieren und konfigurieren müssen.

Wichtig

Weitere Informationen zur Verwendung der modernen Authentifizierung und AAD anstelle von ACS finden Sie im Artikel Upgraden von SharePoint-Anwendungen von Azure Access Control Service auf Azure Active Directory.

Nun erstellen wir eine .NET-Konsolenanwendung, um sharePoint Online-Daten mithilfe der PnP Framework-Bibliothek zu nutzen. Zunächst müssen Sie einen Verweis auf das NuGet-Paket PnP.Framework hinzufügen. In Visual Studio können Sie einfach über die Benutzeroberfläche einen Paketverweis hinzufügen. In Visual Studio Code müssen Sie den folgenden Befehl ausführen.

dotnet add package PnP.Framework

Danach verweist Ihr Projekt nicht nur auf die PnP Framework-Bibliothek, sondern auch auf die CSOM-Bibliothek, die intern von PnP Framework verwendet wird. Im folgenden Codebeispiel erfahren Sie, wie Sie das PnP-Framework verwenden, um eine Verbindung mit SPO herzustellen und einige Daten zu nutzen, indem Sie eine instance der AuthenticationManager-Klasse und die moderne Authentifizierung mit OAuth 2.0 verwenden.

using Microsoft.SharePoint.Client;
using PnP.Framework;

var clientId = "<client-Id>";
var tenantId = "<tenant-Id>";
var redirectUrl = "<redirect-Url>";
var siteUrl = "<target-Site-Url>";

// Create an instance of the AuthenticationManager type
var authManager = AuthenticationManager.CreateWithInteractiveLogin(clientId, redirectUrl, tenantId);

// Get a reference to the ClientContext of CSOM
using (var context = await authManager.GetContextAsync(siteUrl))
{
    // Read web properties
    var web = context.Web;
    context.Load(web, w => w.Id, w => w.Title);
    await context.ExecuteQueryRetryAsync();

    Console.WriteLine($"{web.Id} - {web.Title}");

    // Retrieve a list by title together with selected properties
    var documents = web.GetListByTitle("Documents", l => l.Id, l => l.Title);

    Console.WriteLine($"{documents.Id} - {documents.Title}");

    // Retrieve the top 10 items from the list
    var query = CamlQuery.CreateAllItemsQuery(10);
    var items = documents.GetItems(query);
    context.Load(items);
    await context.ExecuteQueryRetryAsync();

    // Browse through all the items
    foreach (var i in items)
    {
        Console.WriteLine($"{i.Id} - {i["Title"]}");
    }     
}

Der obige Code basiert auf einer interaktiven und webbasierten Anmeldung, um auf eine SharePoint Online-Zielwebsite zuzugreifen. Die Authentifizierung wird von der AuthenticationManager-Klasse von PnP Framework verwaltet, die Ihnen eine einfache und vereinfachte Technik zur Authentifizierung bei SharePoint Online mit einer der folgenden Optionen bietet:

  • Interaktive Benutzerauthentifizierung
  • Benutzername und Kennwort (wobei das Kennwort in einem SecureString gespeichert werden muss)
  • Gerätecode mit einer in Azure Active Directory registrierten Anwendung
  • Autorisierungscodeflow
  • Client-ID und geheimer Clientschlüssel für die reine App-Authentifizierung
  • X.509-Zertifikat für die reine App-Authentifizierung
  • On-Behalf-of-Flow
  • Azure ACS für die reine App-Authentifizierung

Das Codebeispiel enthält id und titel einer Bibliothek mit dem Titel "Dokumente" und ruft die ersten 10 Elemente in der Bibliothek ab, um die ID und den Titel dieser Elemente anzuzeigen. Die Syntax entspricht dem, was Sie in CSOM gewohnt sind. Tatsächlich erhalten Sie ein Kontextobjekt vom Typ Microsoft.SharePoint.Client.ClientContext von CSOM und verwenden es. Sie verwenden jedoch beispielsweise die ExecuteQueryRetryAsync-Methode , die eigentlich eine .NET-Erweiterungsmethode ist, die von PnP Framework bereitgestellt wird, oder Sie verwenden die GetListByTitle-Methode , bei der es sich um eine weitere Erweiterungsmethode handelt, die von PnP Framework bereitgestellt wird. Darüber hinaus gibt es im PnP-Framework viele asynchrone Methoden, mit denen Sie modernen asynchronen Code schreiben können.

In der PnP Framework-Bibliothek gibt es Tausende von Erweiterungsmethoden für die CSOM-Typen, um die Codequalität, Lesbarkeit und Effizienz zu verbessern. Furhtermore, im PnP-Framework gibt es auch die Implementierung der PnP-Bereitstellungs-Engine, die von vielen Unternehmen und von Microsoft selbst verwendet wird, um die Bereitstellung von Websites und Artefakten zu automatisieren. Beispielsweise befindet sich die PnP-Bereitstellungs-Engine hinter den Kulissen der Microsoft Look Book-Website sowie hinter den Kulissen der Bereitstellung von SPO-Demoinhalten im Mandanten von Microsoft 365-Entwicklern.

Nicht zuletzt befindet sich das PnP-Framework im Back-End der meisten Cmdlets, die vom PnP-PowerShell-Modul bereitgestellt werden, und stellt die grundlegende Infrastruktur für die PnP-Seitentransformations-Engine des PnP-Modernisierungsframeworks bereit.

Im Allgemeinen ist das PnP-Framework die "de facto"-Bibliothek, die jeder SharePoint-Entwickler verwenden sollte, um moderne Lösungen für SPO in Microsoft .NET zu erstellen.

Einführung in die PnP Core SDK-Bibliothek

Das PnP Core SDK ist eine neue Bibliothek, die von der Microsoft 365 PnP-Community für die moderne Cloudentwicklung eingeführt wurde. Sie wurde Anfang Februar 2021 live geschaltet und zielt auf .NET Standard 2.0 und .NET 5.0/6.0/7.0 ab. Daher können Sie es auf jeder Plattform (Windows, Linux, MacOS) und in jedem cloudbasierten Dienst verwenden und ist als NuGet-Paket mit dem Namen PnP.Core verfügbar.

Die PnP Core SDK-Bibliothek wurde unter Berücksichtigung der modernen Entwicklung entwickelt. Tatsächlich unterstützt sie nativ Dependency Injection (DI), eine dienstorientierte Architektur, eine fluent-Syntax einschließlich Unterstützung für Language Integrated Query (LINQ) und ein asynchrones Entwicklungsmodell. Es unterstützt auch nativ die Batchverarbeitung von Anforderungen auf REST-Ebene und automatische Wiederholungslogik bei einer Anforderungsdrosselung.

Sie fragen sich vielleicht, was der Unterschied zwischen PnP Framework und PnP Core SDK ist. Tatsächlich wird das PnP Core SDK vom PnP-Framework verwendet und mit einer Denkweise implementiert, die vom CSOM von SharePoint unabhängig ist. In der Tat sind immer mehr neue Funktionen, die in SPO eingeführt werden, nicht notwendigerweise über CSOM verfügbar. Dies ist der Grund, warum das PnP Core SDK eingeführt wurde und für einige Funktionen unter dem Deckmantel von PnP Framework und PnP PowerShell steht.

Das PnP Core SDK wird häufig als PnP Graph First-Bibliothek bezeichnet, da das Ziel dieser Bibliothek darin besteht, modernen .NET-Entwicklern zu helfen, SPO und Microsoft Teams (Teams) über Microsoft Graph zu nutzen. Microsoft Graph ist die Standard-API für die Nutzung von Microsoft 365-Workloads, einschließlich SPO und Teams. Zum Zeitpunkt dieses Schreibens gibt es jedoch einige Funktionen, die noch nicht oder noch nicht vollständig über Microsoft Graph verfügbar sind, z. B. vollständige Unterstützung für moderne Seiten, oder die Verbesserungen erfordern, um vollständig mit dem vergleichbar zu sein, was die REST-API von SPO bietet.

Mit dem PnP Core SDK verfügen Sie über eine Abstraktionsebene über den Back-End-APIs, sodass Sie sich auf Ihr Geschäftsziel konzentrieren können: das Erstellen moderner Lösungen auf der Grundlage von SPO und Teams. Im Hintergrund ist das PnP Core SDK auf Microsoft Graph ausgerichtet, wenn die gesuchte Funktionalität über Graph verfügbar ist, oder wenn es bei Bedarf auf die REST-API von SPO zurückgreift.

Microsoft Graph wächst und entwickelt sich schnell weiter, und mit dieser Technik müssen Entwickler ihren Code nicht kontinuierlich aktualisieren. Sie können sich einfach auf das PnP Core SDK verlassen, das die richtige Wahl für sie trifft. Wenn eine Funktionalität heute in Microsoft Graph fehlt und sie hinzugefügt wird, müssen Entwickler einfach das NuGet-Paket des PnP Core SDK aktualisieren, ohne ihre Codezeile ändern zu müssen.

Das PnP Core SDK ist nur auf Cloudworkloads (SPO und Teams) ausgerichtet und basiert aus Authentifizierungssicht auf einem offenen Modell, das auf OAuth 2.0 basiert. Grundsätzlich können Sie die Authentifizierungsebene mit einer beliebigen Technik implementieren, solange Sie ein gültiges Zugriffstoken bereitstellen. Für den Fall, dass Sie die Microsoft Authentication Library (MSAL) verwenden möchten, gibt es ein dediziertes Paket namens PnP.Core.Auth, das Sie zum Authentifizieren des Zugriffs auf die Zielclouddienste über MSAL verwenden können.

Um das neue PnP Core SDK zu verwenden, müssen Sie lediglich ein .NET-Projekt erstellen, einen Verweis auf das NuGet-Paket mit dem Namen PnP.Core.Auth hinzufügen, das eine Abhängigkeit vom Standard PnP.Core-Paket enthält, und Sie können es verwenden.

Um ein Beispiel zu erstellen, erstellen wir eine .NET-Konsolenanwendung, die auf Dependency Injection über das NuGet-Paket Microsoft.Extensions.Hosting basiert, um einige SharePoint Online-Daten mithilfe der PnP Core SDK-Bibliothek zu nutzen. Um einen Verweis auf PnP.Core.Auth hinzuzufügen, können Sie in Visual Studio einfach den Paketverweis über die Benutzeroberfläche hinzufügen. In Visual Studio Code müssen Sie den folgenden Befehl ausführen.

dotnet add package PnP.Core.Auth
dotnet add package Microsoft.Extensions.Hosting

Jetzt können Sie den Diensthost definieren und die Kette von Diensten erstellen, einschließlich der dienste, die vom PnP Core SDK bereitgestellt werden.

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using PnP.Core.Auth.Services.Builder.Configuration;
using PnP.Core.Services.Builder.Configuration;
using PnP.Core.Services;
using PnP.Core.QueryModel;

var host = Host.CreateDefaultBuilder()
// Configure services with Dependency Injection
.ConfigureServices((hostingContext, services) =>
{
    // Add the PnP Core SDK library services
    services.AddPnPCore();
    // Add the PnP Core SDK library services configuration from the appsettings.json file
    services.Configure<PnPCoreOptions>(hostingContext
        .Configuration.GetSection("PnPCore"));
    // Add the PnP Core SDK Authentication Providers
    services.AddPnPCoreAuthentication();
    // Add the PnP Core SDK Authentication Providers 
    // configuration from the appsettings.json file
    services.Configure<PnPCoreAuthenticationOptions>(hostingContext
        .Configuration.GetSection("PnPCore"));
})
// Let the builder know we're running in a console
.UseConsoleLifetime()
// Add services to the container
.Build();

// Start console host
await host.StartAsync();

// Optionally create a DI scope
using (var scope = host.Services.CreateScope())
{
    // Obtain a PnP Context factory
    var pnpContextFactory = scope.ServiceProvider
        .GetRequiredService<IPnPContextFactory>();
    // Use the PnP Context factory to get a PnPContext for the given configuration
    using (var context = await pnpContextFactory.CreateAsync("SiteToWorkWith"))
    {
        // Retrieving web with lists and masterpageurl loaded ==> SharePoint REST query
        var web = await context.Web.GetAsync(p => p.Title, p => p.Lists,
        p => p.MasterUrl);

        // Output some information about the web
        Console.WriteLine($"{web.Id} - {web.Title}");

        // Browse through the requested lists
        foreach (var l in web.Lists.AsRequested())
        {
            Console.WriteLine($"{l.Id} - {l.Title}");
        }
    }
}

// Cleanup console host
host.Dispose();

Im Codeauszug sehen Sie, dass das PnP Core SDK ein eigenes Kontextobjekt mit dem Namen PnPContext bereitstellt, das Sie verwenden können, um auf SPO oder Teams zuzugreifen, indem Sie ein dediziertes Domänenmodell von Typen verwenden, das vollständig unabhängig von CSOM oder Microsoft Graph ist und die Abstraktionsebene bereitstellt, die zum Entkoppeln des PnP Core SDK von den Back-End-REST-Diensten erforderlich ist. Sie können sich auch die Fluent-Syntax merken, bei der Sie auf die Web-Eigenschaft des PnPContext-instance zugreifen und Methoden darauf aufrufen können, ohne das Webobjekt zuerst instance laden zu müssen.

Um ein Beispiel wie das soeben gesehene ausführen zu können, müssen Sie eine Konfigurationsdatei (appsettings.json) wie im folgenden Codeauszug angeben.

{
    "PnPCore": {
        "Credentials": {
        "DefaultConfiguration": "interactive",
        "Configurations": {
            "interactive": {
                "Interactive": {
                    "RedirectUri": "http://localhost"
                }
            }
        }
        },
        "Sites": {
            "SiteToWorkWith": {
                "SiteUrl": "https://consoto.sharepoint.com/sites/targetSite"
            }
        }
    }
}

Wenn Sie möchten, können Sie die Konfigurationseinstellungen auch einfach mithilfe von Code bereitstellen, ohne sich auf eine JSON-Konfigurationsdatei verlassen zu müssen.

Wichtig

Weitere Informationen zur Verwendung des neuen PnP Core SDK finden Sie in der offiziellen Dokumentation im Dokument PnP Core SDK.

Unabhängig von der Technik, die Sie zum Erstellen eines konfigurierten instance des PnPContext-Typs verwenden, können Sie, sobald sie vorhanden ist, problemlos auf die SPO-Website zugreifen, die sich auf den Kontext bezieht. Falls es sich bei der Website um eine moderne Teamwebsite handelt, können Sie auch auf das Team in Microsoft Teams zugreifen, das mit der Teamwebsite verbunden ist, wie im folgenden Codeausschnitt gezeigt.

// Get a reference to the team connected to the current site, including the FunSettings
var team = await context.Team.GetAsync(t => t.FunSettings);

// Show one of the settings in the FunSettings property
Console.WriteLine($"Are Giphy allowed? {team.FunSettings.AllowGiphy}");

Ein weiteres interessantes Feature des PnP Core SDK ist die Unterstützung für LINQ-Abfragen (Language Integrated Query), sodass Sie das Objektmodell des PnP Core SDK mithilfe von LINQ abfragen können. Im folgenden Codeauszug können Sie beispielsweise sehen, wie Die Listen des aktuellen Webobjekts nach TemplateType gefiltert abgefragt werden, sodass nur die Dokumentbibliotheken abgerufen werden können.

// Define a LINQ query to retrieve only the document libraries of the current web
var lists = (from l in context.Web.Lists
            where l.TemplateType == PnP.Core.Model.SharePoint.ListTemplateType.DocumentLibrary
            select l);

Console.WriteLine("=> Here are all the document libraries:");

// Browse the lists resulting from the LINQ query
foreach (var l in lists)
{
    Console.WriteLine($"{l.Id} - {l.Title} - {l.TemplateType}");
}

Kombinieren der Verwendung von PnP Framework und PnP Core SDK

Nachdem Sie diesen Artikel gelesen haben, fragen Sie sich vielleicht, was Sie wann verwenden sollten.

Wenn Sie ein SharePoint-Entwickler sind, der an der Arbeit mit CSOM gewöhnt ist, oder wenn Sie bereits über ein vorhandenes Projekt verfügen, das auf PnP Sites Core und CSOM basiert, sollten Sie sich auf PnP Framework verlassen und mit dem Erstellen moderner Lösungen beginnen, indem Sie die umfangreichen Erweiterungen und Hilfsprogramme nutzen, die von der neuen PnP Framework-Bibliothek bereitgestellt werden.

Wenn Sie ein .NET-Entwickler sind und bereit sind, eine neue moderne Lösung für SPO zu erstellen, beginnen Sie mit der Arbeit mit dem PnP Core SDK und nutzen Sie die Microsoft Graph- und SPO-REST-APIs mit einer allgemeinen Abstraktionsebene.

Wenn Sie möchten, können Sie sogar beide Bibliotheken verwenden, je nachdem, was Sie tun müssen. Wenn Sie beispielsweise eine automatisierte Bereitstellung von Websites mithilfe der PnP-Bereitstellungs-Engine durchführen müssen, müssen Sie sich unbedingt auf PnP Framework verlassen. Wenn Sie SharePoint-Objekte mit LINQ abfragen müssen, müssen Sie sich unbedingt auf das PnP Core SDK verlassen. Und Sie können beide verwenden und den Kontext von einem zum anderen wechseln. Im folgenden Codeauszug sehen Sie beispielsweise, wie Sie vom PnP-Framework zum PnP Core SDK wechseln und denselben Kontext verwenden.

// Create an instance of the AuthenticationManager type
var authManager = AuthenticationManager.CreateWithInteractiveLogin(clientId, redirectUrl, tenantId);

// Get a reference to the ClientContext of CSOM
using (var csomContext = await authManager.GetContextAsync(siteUrl))
{
    // Use CSOM to load the web title
    csomContext.Load(csomContext.Web, p => p.Title);
    csomContext.ExecuteQueryRetry();
    Console.WriteLine($"Title from PnP Framework: {csomContext.Web.Title}");

    using (PnPContext pnpCoreContext = PnPCoreSdk.Instance.GetPnPContext(csomContext))
    {
        // Use PnP Core SDK (Microsoft Graph / SPO Rest) to load the web title
        var web = await pnpCoreContext.Web.GetAsync(p => p.Title);

        Console.WriteLine($"Title from PnP Core SDK: {web.Title}");
    }
}

Im folgenden Codeauszug sehen Sie, wie Sie vom PnP Core SDK zu PnP Framework wechseln und denselben Kontext verwenden.

using (var scope = host.Services.CreateScope())
{
    // Obtain a PnP Context factory
    var pnpContextFactory = scope.ServiceProvider
        .GetRequiredService<IPnPContextFactory>();
    // Use the PnP Context factory to get a PnPContext for the given configuration
    using (var pnpCoreContext = await pnpContextFactory.CreateAsync("SiteToWorkWith"))
    {
        // Use PnP Core SDK (Microsoft Graph / SPO Rest) to load the web title
        var web = await pnpCoreContext.Web.GetAsync(p => p.Title);
        Console.WriteLine($"Title from PnP Core SDK: {web.Title}");

        using (ClientContext csomContext = PnPCoreSdk.Instance.GetClientContext(pnpCoreContext))
        {
            // Use CSOM to load the web title
            csomContext.Load(csomContext.Web, p => p.Title);
            csomContext.ExecuteQueryRetry();

            Console.WriteLine($"Title from PnP Framework: {csomContext.Web.Title}");
        }   
    }
}

Daher können Sie sich frei durch die beiden Bibliotheken bewegen und die neue Codierungserfahrung genießen.

Empfohlene Inhalte

Weitere Informationen zu diesem Thema finden Sie in den folgenden Dokumenten: