it-swarm.com.de

Wie verwaltet man ein Client-Kontextobjekt in einer separaten Klassenbibliothek?

Ich versuche, eine library (Klassenbibliothek) für Sharepoint zu erstellen, die alle Sharepoint-DLLs hat, um mit dem Sharepoint-Server zu interagieren, um Dateien, Dokumente hochzuladen und Dokumentbibliothek und Dokumentensatz zu erstellen.

Diese Bibliothek könnte nun von clients wie Webanwendungen (asp.net webform oder mvc) oder Konsolenanwendungen oder Webapi/wcf-Diensten oder Windows form verwendet werden.

Daher bin ich etwas verwirrt mit dem Erstellen von Repository-Pattern und einer Arbeitseinheit, um das Kontextobjekt des Clients zu verwalten.

Ich bin nicht sicher, ob ich für jeden Vorgang die Erstellung eines Client-Kontexts zulassen soll, ob er einmalig erstellt und wiederverwendet werden soll oder ob der Client-Kontext jedes Mal erstellt wird.

Ich habe eine Suchfunktion gefunden, konnte jedoch keine Referenz oder Artikel finden, um die Repository-Ebene so zu erstellen, wie sie im Fall von Entity framework DbContext erstellt wurde.

Ich verwende Client-Side Object Model (CSOM-Bibliothek) und in meiner Bibliothek geht es ausschließlich um das Content Management-System zur Verwaltung von Dateien und Metadaten.

Ich freue mich über jede Hilfe :)

Update: Beispielcode zum Hochladen einer Datei in die Sharepoint-Domäne

ClientContext context = new ClientContext("http://SiteUrl"); // Starting with ClientContext, the constructor requires a URL to the server running SharePoint. 
context.Credentials = new SharePointOnlineCredentials(username, password);

// The SharePoint web at the URL.
Web myWeb = context.Web;

List myLibrary = myWeb.Lists.GetByTitle("MyProject"); //This is called document library so in sharepoint document Library is the root where we can create
                                                       //Document Set(Advance version of folder) or folder(Simple Folder) or upload files directly inside document library

FileCreationInformation info = new FileCreationInformation();
info.Url = "Sample.txt";
info.Overwrite = true;
info.Content = System.IO.File.ReadAllBytes("C://sample.txt"); //This will be user uploaded file that will be dynamic
myLibrary.RootFolder.Files.Add(info);
context.ExecuteQuery(); // Execute the query to the server.This is like EF SaveChanges method

Einige Verweise: https://docs.Microsoft.com/en-us/previous-versions/msp-n-p/ff649690(v=pandp.10)

https://docs.Microsoft.com/de-de/sharepoint/dev/sp-add-ins/complete-basic-operations-using-sharepoint-client-library-code

https://docs.Microsoft.com/de-de/previous-versions/office/developer/sharepoint-2010/ee538685%28v%3doffice.14%29

https://sharepoint.stackexchange.com/questions/96180/sharepoint-2013-csom-is-it-better-to-pass-a-context-object-around-or-a-url

8

Zu Ihrer ersten Frage:

Ich bin nicht sicher, ob ich für jeden .__ die Erstellung eines Client-Kontexts zulassen darf. Vorgang oder ob der Client-Kontext einmal erstellt und wiederverwendet wird oder ob jedes Mal ein Kundenkontext erstellt werden soll.

Warum lassen Sie die Entwickler Ihre Bibliothek nicht wählen? Sie geben also den Kontext an, und sie können ihn initialisieren und in dem von ihnen benötigten Umfang halten.

Wenn Ihre Bibliothek beispielsweise in einer Website verwendet wird, möchten sie sie möglicherweise für jede Anforderung initialisieren. Wenn Ihre Bibliothek jedoch in einer Desktopanwendung verwendet wird, möchten Sie sie möglicherweise nur einmal pro Fenster initialisieren.

Zu Ihrer zweiten Ausgabe:

Ich habe viel gesucht, konnte aber keine Referenz oder Artikel zu .__ finden. Erstellen Sie die Repository-Ebene wie bei Entity Framework DbContext.

Das Repository und die Arbeitseinheit sind nur Abstraktionsebenen, die Sie auf jeden Kontext anwenden können. Ein Repository implementiert einen Satz verwandter Operationen für ein bestimmtes Objekt oder eine bestimmte Entität, während eine Arbeitseinheit einen Satz verwandter Operationen für eine oder mehrere Entitäten in einem bestimmten Kontext (eine Datenbanktransaktion usw.) implementiert.

IMHO ein Repository ist für das, was Sie versuchen, nicht sinnvoll, Sie könnten jedoch eine Arbeitseinheit implementieren, die eine ClientContext-Instanz umschließt.

Beginnen Sie zunächst mit einer Schnittstelle und definieren Sie die Methoden, die Sie zur Verfügung stellen möchten, zum Beispiel:

public interface IContentManagerUnitOfWork
{
    IEnumerable<List> GetLists();
    List CreateList(ListCreationInformation listCreationInformation);
    List GetListByTitle(string title);
    [...]
}

Dann implementieren Sie es, hier ist eine Idee:

public class ContentManagerUnitOfWork : IContentManagerUnitOfWork, IDisposable
{
    private ClientContext clientContext;
    private Web web;

    public ContentManagerUnitOfWork(string url, username, password)
    {
        clientContext = new ClientContext(url);
        clientContext .Credentials = new SharePointOnlineCredentials(username, password);

        web = context.Web;
    }

    public IEnumerable<List> GetLists()
    {
        clientContext.Load(web.Lists);
        clientContext.ExecuteQuery(); 
        return web.Lists;
    }

    List CreateList(ListCreationInformation listCreationInformation)
    {
        List list = web.Lists.Add(listCreationInformation); 
        list.Update(); 
        clientContext.ExecuteQuery(); 
        return list;
    }

    List GetListByTitle(string title)
    {
        return web.Lists.GetByTitle("Announcements"); 
    }

    public void Dispose()
    {
        clientContext.Dispose();
    }
}

Jeder Entwickler, der Ihre Bibliothek verwendet, kann die Arbeitseinheit einfach mit den von Ihnen bereitgestellten Methoden verwenden:

using (var unitOfWork = new ContentManagerUnitOfWork("http://SiteUrl", username, password))
{
     var lists = unitOfWork.GetLists();
}

Natürlich ist dies nur ein grundlegendes Beispiel. Sie sollten es an Ihre Bedürfnisse anpassen und sicherstellen, dass es die richtige Art ist, mit Sharepoint zu interagieren. Ich hoffe, es bringt dich trotzdem zum Laufen.

3
Isma

Ich denke, Sie müssen einen Authentifizierungsdienst im WCF-Dienst erstellen (siehe unten), der sich um alle angemeldeten Benutzer kümmert. Immer wenn Sie eine neue Anfrage erhalten, erhalten Sie Informationen zu diesem Benutzer, wenn es sich um einen echten Benutzer handelt oder nicht

    [ServiceContract]
    public interface IAuthenticationService
    {
       [OperationContract]
       ClientInfo ChangeSessionUser(User user);
       [OperationContract]
       ClientInfo GetSessionUserInfo();
       [FaultContract(typeof(ServiceFault))]
       [OperationContract]
       ClientInfo Login(LoginCredentials credentials);
       [OperationContract]
       void Logout(string id);
       [FaultContract(typeof(ServiceFault))]
       [OperationContract]
       void RemoveInvalidUserLogins();
       [OperationContract]
       void RemoveSesseionFromCache(string id);
       [FaultContract(typeof(ServiceFault))]
       [OperationContract]
       bool ValidateUser(LoginCredentials credentials);
    }
0
Ankur Shah