SharePoint 2010 - Meilleures pratiques: Comment gérer les assemblées [Discussion]

Question

Il y a une discussion qui se poursuit pour des années serviales lors de la programmation pour SharePoint.

Dans Visual Studio Vous pouvez ajouter une solution SharePoint, qui sera convertie en un fichier .WSP à déployer. Ce fichier .WSP contiendra tous les fichiers d'assemblage requis.

Comment gîtes-tu les fichiers de codeBeHind pour: récepteur d'événement, récepteur de fonctionnalités, page ASPX?

Placez-vous ce fichier .cs dans votre dossier SharePoint? (De cette façon, vous devrez déployer une .dll de votre projet SharePoint Project Aswell)

ou déplacez-vous toute la logique de code sur un (ou plusieurs) projets différents (bibliothèques de classe)?

Qu'est-ce que vous faites par exemple dans le deuxième exemple:

• Faites un clic droit, ajoutez un nouvel élément, récepteur d'événement
• Déplacez le fichier .CS à un autre projet
• Modifiez les informations de montage à l'intérieur du fichier éléments.xml

  Dans le premier exemple, nous ne déplacons pas ces fichiers, il suffit de les garder comme VS2010 les ajoute.

  Je ne dis pas de quelle manière je préfère, je veux juste recevoir beaucoup d'informations. Ne dis pas que "l'option 2 est mauvaise". J'aimerais vraiment savoir pourquoi et pourquoi pas!

  merci

  EDIT:

  Ma question ici n'a rien à voir avec des extensions, etc.

  Je parle de vous assurer que votre solution SharePoint ne contient aucun fichier .CS. De cette façon, il n'est pas nécessaire d'être un assemblage dans le GAC pour cette solution.

  Exemple: j'ai client.sps.intranet.solution (= la solution pour générer WSP, donc un élément de projet SharePoint vide).

  Si j'ajoute simplement une fonctionnalité et un récepteur de fonctionnalité, un fichier .cs est généré et (après le déploiement) un fichier client.sps.intranet.solution.dll est placé dans le cache de montage global.

  C'est ce que certaines personnes ne veulent pas avoir !!! (Je ne comprends pas pourquoi, c'est pourquoi je demande des opinions).

  Pour résoudre ceci, ils créent un projet à l'intérieur de cette solution nommée: "Customer.SPS.Intranet.logic", cette solution contiendra tous les fichiers de code de la fonctionnalité de récepteur.

  Cela signifie que nous devons modifier le fichier de fonctionnalité.xml pour utiliser la classe du récepteur situé dans le projet "Logic". De cette façon, nous conservons le "client.sps.intranet.solution" propre et nous n'utiliserons que pour emballage. Donc, il n'y aura pas d'assemblée déployée sur le GAC nommé "client.sps.intranet.solution.dll" ... à la place d'un ensemble client.sps.intranet.logic.dll est déployé sur le GAC.

Answer 1

Aaah, la question éternelle des solutions et des DLL. :-) Pourquoi séparer, pourquoi pas, et quand? Je ne travaille pas au guichet automatique, je suis en vacances, mais comme vous m'avez demandé de jeter un coup d'œil, je vais simplement résumer quelques emporter et que je le prends. Donc, ma réponse est basée sur une expérience personnelle et une vue. (Désolé Stackexhange)

x ne pas diviser "code derrière" et UI conduit au code difficile à maintenir. Quelque chose que j'ai vu sur différents projets est que les développeurs inexpérimentés ne fonctionnent pas bien avec le "code derrière" (C # classes à côté de XML / ASPX), ils ont tendance à écrire plus de logique dans le code de l'arrière car ils ont un accès direct à l'interface utilisateur. Sur un projet particulier, j'ai vu une "nouvelle" page de 1500 lignes (qui est déjà énorme) et la page "Modifier" était essentiellement une copie et une pâte de la nouvelle page. Bien sûr, c'est une "mauvaise programmation", il n'est pas inhérent de mettre le code derrière à côté des artefacts. Mais les mauvaises habitudes sont difficiles à changer et ce modèle de travail peut aider à aggraver les choses. Dans ce cas, rend la classe CS d'abord comme un contrôle et ayant une sorte de classe héritée pour la classe d'édition, aurait été plus facile à entretenir. Une fois créé, vous pouvez faire hériter vos pages ASP de ces classes.

x ne pas diviser "code derrière" et l'interface utilisateur conduit à des classes avec trop de logique. Une autre chose sur ce projet est que la nouvelle page que la page d'édition avait des connexions directes aux bases de données SQL externes. Ils ont utilisé des connexions SQL directes qui ont créé une surcharge de code et de maintenance. Une approche en couches aurait grandement aidé.

x Une application en couches nécessite des assemblys distincts. Eh bien, la superposition est bonne! Avez-vous besoin d'un assemblage séparé pour cela? Pas nécessairement. Vous pouvez regrouper votre logique, la couche d'accès de données, etc. dans des dossiers / espaces de noms séparés dans votre montage. Ce sont aussi des couches. "Mais pourquoi devrais-je les diviser?" Il a tendance à être une bonne pratique. Pourquoi? Eh bien, vous évitez l'utilisation accidentelle d'une logique plus profonde (par exemple, des connexions SQL), car cette logique n'est référencée que dans une couche DA. Un autre avantage est qu'il est potentiellement plus facile de remplacer les couches supérieures d'une autre couche. Dites une autre interface utilisateur ou une interface mobile. Vous pouvez la pousser encore plus loin et rendre des couches plus basses plus génériques, vous pouvez donc les utiliser plus tard. C'est ainsi que des frameworks NHibernate et EF peuvent être créés.

X "C'est gentil, mais c'est juste le développement ASP.NET." À droite, mais les mêmes principes et idées peuvent être utilisés lors du développement des artefacts SharePoint, tels que les récepteurs. Pourquoi ne pas fonctionner votre chemin vers des récepteurs génériques pouvant être paramétrés avec des propriétés de fonctionnalité ou des propriétés de dossier? La réutilisation de la logique entraîne principalement des solutions plus stables.

x Séparer les tests d'encourage (unité). Une fois que vous commencez à séparer et à créer une classe plus générique, etc., ce n'est plus un long étirement d'utiliser des interfaces et des modèles. Cela signifie que les tests unitaires seront plus faciles à mettre en œuvre (bien que nous devions réellement utiliser TDD), car nous pouvons vous moquer plus facilement. Regardez le cadre MVC et la façon dont les choses sont bien séparées. Cela fonctionne également pour SharePoint.

Donc de résumer mon 2c (et un changement ;-)), vous pouvez utiliser le code derrière la marée directement sur votre artefact, mais je préfère pas. Je préfère utiliser un code de réutilisation, générique et testable, que d'avoir des récepteurs et du code correspondant automatiques à des artefacts (bien que vous n'ayez pas besoin de modifier le modèle de fonctionnalité XML dans la casse manuelle, vous devez simplement ajouter le récepteur de fonctionnalités dans les propriétés) et La facilité de localisation (j'utilise l'instant Aller à VS2010) mais à la fin, c'est tout ce que vous et votre projet préférez. : -)

Answer 2

En réalité, personnellement, jamais rencontré une solution dans laquelle les fichiers d'une solution SharePoint ont été déplacés en dehors d'un projet, à l'exception de certaines situations où vous avez identifié des pièces réutilisables: par exemple. Méthodes d'extension, code de gestionnaire d'événements de base. Il y a aussi une raison de ne pas le déplacer, par ex. Habituellement, VS 2010 utilise le GUID auquel les classes sont décorées pour un travail interne sur celui-ci relie le gestionnaire. Il pourrait donc accumuler correctement les dépendances. En outre, tous les fichiers binaires sont de toute façon construits, donc code-à côté (plus de code-indicatif dans SP2010) est déjà intégré. En outre, l'enregistrement de SafeControls (pièces Web, contrôles personnalisés, etc.) ne serait pas enregistré correctement car Visual Studio pourrait inclure des assemblages externes dans votre colis, mais il ne scrutait pas nécessairement ces assemblées pour le code actuel - vous devriez faire tout ce qui manuellement - mauvais pour la productivité.

Ce sont des réflexions initiales, pourrait revenir avec d'autres, mais la règle inférieure: vous ne réutilisez pas ces pièces - alors mieux les laisser où vs propose de. Planifiez plutôt quel type de fonctionnalité que vous déployez, quelles dépendances que vous avez possédez, caractéristiques, ordre d'activation, etc.

J'espère que cela aide, C: \ marius