web-dev-qa-db-fra.com

Comment gérer un objet de contexte client dans une bibliothèque de classes séparée?

J'essaye de créer une bibliothèque (bibliothèque de classes) pour sharepoint qui aura toutes les dll sharepoint pour interagir avec le serveur sharepoint pour télécharger des fichiers, des documents et créer une bibliothèque de documents et un ensemble de documents.

Maintenant, cette bibliothèque peut être utilisée par clients comme une application Web (asp.net webform ou mvc), une application console ou des services Web api/wcf ou Windows Form.

Je suis donc un peu confus avec la création de patterns de référentiel et d'une couche d'unité de travail afin de gérer les objets de contexte client.

Je ne sais pas s'il faut autoriser la création d'un contexte client pour chaque opération ou s'il faut créer le contexte client une fois et le réutiliser ou si créer un contexte client à chaque fois.

J'ai beaucoup cherché, mais je n'ai trouvé aucune référence ou article permettant de créer une couche de référentiel similaire à celle créée dans le cas de Entity framework DbContext.

J'utilise modèle d'objet côté client (bibliothèque CSOM) et ma bibliothèque est entièrement consacrée au système de gestion de contenu pour gérer les fichiers et les métadonnées.

Je vais apprécier toute aide :)

Update: Exemple de code pour télécharger le fichier sur le domaine SharePoint

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

Quelques références: https://docs.Microsoft.com/en-us/previous-versions/msp-n-p/ff649690(v=pandp.10)

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

https://docs.Microsoft.com/en-us/previous-versions/office/developer/sharepoint-2010/ee538685%28voffs3doffice.14%29

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

c#sharepoint-2013repository-patternunit-of-workcsom
8
ILoveStackoverflow

Concernant votre première question:

Je ne suis pas sûr d'autoriser la création d'un contexte client pour chaque opération ou si créer le contexte client une fois et réutiliser ou créer ou non un contexte client à chaque fois.

Pourquoi ne pas laisser les développeurs utilisant votre bibliothèque choisir? c’est-à-dire que vous fournissez le contexte et qu’ils peuvent l’initialiser et le garder dans la portée dont ils ont besoin.

Par exemple, si votre bibliothèque est utilisée dans un site Web, ils peuvent vouloir l'initialiser à chaque demande, mais si votre bibliothèque est utilisée dans une application de bureau, ils peuvent vouloir l'initialiser une seule fois par fenêtre.

Concernant votre deuxième numéro:

J'ai beaucoup cherché mais je n'ai trouvé aucune référence ou article à créer une couche de référentiel comme celle-ci dans le cas de Entity cadre DbContext.

Les modèles de référentiel et d'unité de travail ne sont que des couches d'abstraction que vous pouvez appliquer à n'importe quel contexte. Un référentiel implémentera un ensemble d'opérations liées pour un objet ou une entité donné, tandis qu'une unité de travail implémentera un ensemble d'opérations associées pour une ou plusieurs entités dans un contexte donné (une transaction de base de données, etc.).

IMHO un référentiel n'a pas beaucoup de sens pour ce que vous essayez de faire, vous pouvez toutefois implémenter une unité de travail encapsulant une instance ClientContext.

Commençons d’abord par une interface définissant les méthodes à exposer, par exemple:

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

Ensuite, vous le mettez en œuvre, voici une idée:

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

Ensuite, tout développeur utilisant votre bibliothèque peut simplement utiliser l'unité de travail avec les méthodes que vous fournissez:

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

Bien sûr, il ne s'agit que d'un exemple de base varié, vous devez l'adapter à vos besoins et vous assurer qu'il s'agit du moyen approprié pour interagir avec Sharepoint. J'espère que cela vous fera avancer, cependant.

3
Isma

Je pense que vous devez créer un service d'authentification dans le service WCF, comme ci-dessous, qui prendra en charge tous les utilisateurs connectés. Chaque fois qu'une nouvelle demande vous parvient pour obtenir des détails sur cet utilisateur s'il est un utilisateur authentique ou non, effectuez-le en conséquence.

    [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