Premier aperçu

Outils Visual Studio 2010 pour le développement SharePoint

Steve Fox

Le développement SharePoint a toujours revêtu une part de mystère aux yeux de nombreux développeurs, qui estiment que le développement pour cette plateforme est peu convivial et hors de leur portée. La communauté de développeurs est également partagée quant au jeu d'outils à utiliser. Par exemple, certains développeurs utilisent un mélange de bibliothèques de classes, de dossiers de projets manuels avec fichiers de configuration XML et d'événements de sortie post-build afin de générer des fonctionnalités et des solutions pour SharePoint. D'autres utilisent STSDEV, un outil communautaire, ou encore les Extensions Visual Studio pour Windows SharePoint Services (VSeWSS) dans le but de générer différentes applications et solutions et de les déployer sur SharePoint. Autrement dit, il existe différentes manières de déployer des fonctionnalités et des packages de solutions sur SharePoint. Malgré ces difficultés, la communauté de développeurs SharePoint a connu, et connaît encore, une forte croissance (environ 600 000 développeurs à ce jour). Fort de ce constat, Visual Studio 2010 proposera aux développeurs une excellente voie d'accès au développement SharePoint avec les nouveaux outils SharePoint intégrés.

SharePoint 2010 constitue un grand pas en avant en tant que plateforme de développement, non seulement en raison du jeu de fonctionnalités enrichi pris en charge par cette plateforme, mais également parce que des efforts conséquents ont été investis dans la suite d'outils conçus pour rendre le processus de développement plus productif et plus accessible aux développeurs de tous niveaux. Les deux principaux outils de développement de SharePoint 2010 sont SharePoint Designer 2010 et Visual Studio 2010. (Le jeu d'outils associé destiné aux concepteurs est la suite Expression.) Cet article fournit un premier aperçu du développement SharePoint 2010 ; il présente les outils SharePoint intégrés à Visual Studio 2010 (avec une introduction aux nouveaux modèles de projet) et illustre comment créer et déployer un exemple de composant Visual Web Part.

Outils SharePoint dans Visual Studio 2010

Un certain nombre d'aspects du développement SharePoint dans Visual Studio 2010 sont tout particulièrement dignes d'intérêt. Premièrement, vous disposez de modèles de projet SharePoint intégrés, ce qui vous permet de commencer immédiatement le développement de solutions. Deuxièmement, les outils sont standardisés et basés sur la norme d'empaquetage WSP (Windows SharePoint Package) ; ainsi, lorsque vous importez ou déployez une solution sur SharePoint, Visual Studio la traite comme un package de solution. Troisièmement, les Outils SharePoint dans Visual Studio 2010 intègrent quelques précieuses fonctionnalités de déploiement et d'empaquetage telles que le retrait de solution et les configurations de déploiement personnalisées. Et pour finir, le nouvel Explorateur SharePoint offre une vue des artefacts natifs et personnalisés (par exemple, les listes et les flux de travail) qui existent sur votre serveur SharePoint. Bien entendu, il s'agit seulement d'une petite partie des nombreuses fonctionnalités qui représentent une extension majeure d'un jeu d'outils Visual Studio conçu pour faciliter le travail de la communauté de développeurs SharePoint.

Nous pouvons également mentionner quelques-unes des améliorations apportées à SharePoint 2010 qui peuvent s'utiliser dans le contexte de Visual Studio 2010. Par exemple, le nouveau modèle objet client vous permet d'accéder à des objets SharePoint par le biais d'une DLL référencée, par opposition aux appels de service Web. (Dans SharePoint 2007, l'accès aux données de listes SharePoint, par exemple, s'effectue à l'aide d'un service Web ASP.NET.) De plus, LINQ pour SharePoint permet de tirer parti de la puissance de LINQ dans SharePoint, vous permettant par exemple de traiter les listes en tant qu'objets fortement typés. Silverlight (surtout lorsqu'il est combiné au modèle objet client) est pris en charge de manière native dans SharePoint 2010 ; plus besoin de manipuler le fichier web.config pour commencer le développement. Les solutions bac à sable (sandbox) offrent également un moyen de générer des composants WebPart SharePoint et de les déployer sur un site sans qu'aucune intervention administrative ne soit nécessaire ; autrement dit, vous pouvez déployer un composant WebPart sur un site SharePoint et l'exécuter dans le contexte de ce site soit dans une instance locale de SharePoint, soit dans le nuage à l'aide de la version hébergée de SharePoint. Pour finir, les listes de données externes font de l'interaction avec les systèmes métier un processus de lecture/écriture, ce qui constitue réellement un grand bond en avant si l'on considère la prise en charge d'outils qui vous permet de générer des intégrations métier rapidement et efficacement. Pour chacune des ces innovations dans SharePoint 2010, Visual Studio 2010 fournit une certaine prise en charge aux professionnels du développement, que ce soit par le biais de modèles de projet ou d'API. Le développement SharePoint n'aura jamais été aussi simple.

Développement d'un projet de composant Visual Web Part

L'un des artefacts les plus couramment générés et déployés par les développeurs dans SharePoint est le composant WebPart. Ceci est logique, puisque les composants WebPart constituent l'un des principaux blocs de construction de SharePoint. SharePoint s'appuyant sur ASP.NET, le composant WebPart hérite de fonctionnalités clés de l'architecture de composants WebPart ASP.NET.

L'un des nouveaux modèles de projet dans Visual Studio 2010 est le modèle de projet Composant Visual Web Part, qui permet aux développeurs de concevoir visuellement un composant WebPart pouvant être déployé sur SharePoint. Si vous débutez dans le développement SharePoint, il s'agit d'un excellent moyen de commencer à générer des applications personnalisées pour SharePoint 2010. Le composant Visual Web Part que j'utiliserai en guise d'illustration contient du code autonome qui calcule des coûts de produits et affiche des informations dans une interface utilisateur de composant WebPart simple.

Figure 1 Nouveaux modèles de projet SharePoint

Figure 2 Mode concepteur pour un composant Visual Web Part

Assurez-vous que la version beta 2 de Visual Studio 2010 et la version beta 2 de SharePoint 2010 sont installées sur un ordinateur Windows Server 2008 64 bits. Ouvrez Visual Studio 2010, cliquez sur Fichier, sur Nouveau projet, puis naviguez jusqu'au nœud SharePoint dans la section Modèles installés. La figure 1 illustre les différents types de modèles de projet disponibles. Par exemple, le modèle Importer un projet VSeWSS fournit un itinéraire de mise à niveau à partir de vos projets VSeWSS actuels, les modèles de flux de travail vous permettent de créer et de déployer des projets de flux de travail sur SharePoint, le modèle Définition de site fournit une infrastructure au niveau site que vous pouvez générer et déployer, et Importer le package de solution SharePoint est le modèle qui vous permet d'importer des fichiers WSP pour un redéploiement sur une instance de serveur locale. Pour cette procédure, sélectionnez le modèle de projet Composant Visual Web Part, spécifiez un nom (par exemple, ExempleProjetComposantWebPart) et un emplacement pour le projet, puis cliquez sur OK.

Une fois que vous avez créé un projet, Visual Studio 2010 crée plusieurs fichiers par défaut. Développez les nœuds du projet dans l'Explorateur de solutions pour afficher les fichiers. Les principaux fichiers avec lesquels vous travaillerez dans cet article se trouvent dans le nœud SampleWebPartProject. Notez que le composant Visual Web Part par défaut se nomme VisualWebPart1. Pour modifier ce nom, cliquez avec le bouton droit sur le nœud VisualWebPart1 dans l'Explorateur de solutions, sélectionnez Renommer, puis entrez un nouveau nom pour votre composant WebPart.

Notez également la présence, dans l'Explorateur de solutions, des nœuds Fonctionnalités et Package. Il s'agit de nouveaux composants d'infrastructure de Visual Studio 2010 qui empaquètent une solution SharePoint à l'aide d'une fonctionnalité SharePoint. Pour les développeurs qui ne connaissent pas encore SharePoint, une fonctionnalité organise l'application d'une manière comprise par SharePoint. Les fonctionnalités peuvent être déployées dans SharePoint au niveau du site ou au niveau Web, par exemple. Une fonctionnalité est structurée par le biais d'un ensemble de fichiers de configuration XML et référence également (selon le niveau d'approbation de votre application) l'assembly à partir du Global Assembly Cache. Plus spécifiquement, chaque fonctionnalité a son propre dossier dans la hiérarchie de dossiers SharePoint, et les fichiers de configuration résident dans ce dossier et procurent les métadonnées nécessaires à la fonctionnalité. Le package contient des fonctionnalités et autres biens, et est utilisé lorsque vous déployez des solutions sur SharePoint. C'est également dans le package que l'emplacement du déploiement d'assembly est déterminé. Visual Studio 2010 introduit un concepteur de package qui facilite grandement l'affichage et la gestion des packages. Si vous double-cliquez sur le nœud Package, le concepteur s'ouvre. Celui-ci vous permet d'ajouter et de supprimer des fonctionnalités de votre package déployable. Ce concepteur facilite pour les développeurs la création de solutions SharePoint par l'ajout de fonctionnalités.

Rebasculez vers l'Explorateur de solutions, cliquez avec le bouton droit sur le fichier ProductInfoUserControl.ascx, puis choisissez Afficher dans le concepteur. Une fenêtre s'affiche alors, dans laquelle vous pouvez faire glisser et déplacer des contrôles de la boîte à outils vers la surface de conception de composants WebPart. Vous remarquerez qu'il existe trois vues : Design, Fractionner et Code. Dans cet exemple, j'ai ajouté (tapé) un titre et quelques contrôles, y compris des zones de texte et un bouton permettant de calculer le coût d'un produit. J'ai également entré des étiquettes pour les contrôles qui ont été ajoutés à la page (voir la figure 2).

Après avoir terminé la disposition de votre composant Visual Web Part, vous pouvez ajouter des gestionnaires d'événements pour le bouton. Mais avant cela, nous allons jeter un œil au code source du composant Visual Web Part. Comme vous le constatez en observant l'extrait de code sur la figure 3, Visual Studio ajoute un style automatique à l'interface utilisateur sous la forme de syntaxe CSS. On observe également les contrôles (et, dans le cas de la liste déroulante, la collection d'éléments) qui composent l'interface utilisateur. Notez que pour plus de clarté, j'ai supprimé les directives générées automatiquement et incluses en haut de la source.

Pour ajouter des gestionnaires d'événements au composant WebPart, double-cliquez sur le bouton. La fenêtre code-behind s'ouvre. Un événement onClick est également ajouté à la conception de contrôle ASCX. Par exemple, sur la figure 3, notez l'événement onclick="btnCalcPrice_Click" inclus dans btnCalcPrice. Le code-behind, illustré sur la figure 4, contient du code simple qui vous permet de calculer le prix du produit sélectionné dans la zone de liste. Les principaux éléments du code sont les variables de niveau classe (les doubles), qui représentent la méthode que j'ai adoptée pour calculer le coût du produit, la collection List of Products (qui contient plusieurs objets Products ajoutés à la zone de liste) et l'événement btnCalcPrice_Click. Lorsque la page est chargée dans SharePoint, le code appelle la méthode generateProductList, qui remplit la zone de liste. L'événement btnCalcPrice_Click calcule ensuite le coût d'un produit spécifique (en fonction de la sélection effectuée par l'utilisateur) et affiche les informations dans la zone de liste dans l'interface utilisateur.

Figure 3 Code source de SalaryCalcWebPartUserControl.ascx

<style type="text/css">
.style1
{
font-family: Calibri;
font-size: medium;
font-weight: bold;
}
.style2
{
font-family: Calibri;
font-size: small;
font-weight: bold;
}
</style>
<p class="style1">
Product Catalog</p>
<p class="style2">
Product:  
<asp:DropDownList ID="dropdwnProducts" 
runat="server" Height="20px"
style="margin-left: 21px" Width="200px">
<asp:ListItem>Helmet</asp:ListItem>
<asp:ListItem>Stick</asp:ListItem>
<asp:ListItem>Skates</asp:ListItem>
<asp:ListItem>Elbow Pads</asp:ListItem>
<asp:ListItem>Kneepads</asp:ListItem>
</asp:DropDownList>
</p>
<p class="style2">
Description: <asp:TextBox ID="txtbxDescription" runat="server"
Width=”200px” Enabled=”False”></asp:TextBox>
</p>
<p class="style2">
SKU:
<asp:TextBox ID="txtbxSKU" runat="server" style="margin-left: 48px"
Width="200px" Enabled="False"></asp:TextBox>
</p>
<p class="style2">
Price:<asp:TextBox ID="txtbxPrice" runat="server"
style="margin-left: 48px"
Width="200px" Enabled="False"></asp:TextBox>
</p>
<p class="style2">
Quantity:
<asp:TextBox ID="txtbxQuantity" runat="server" 
Width="200px" Enabled="False"></asp:TextBox>
</p>
<p class="style1">
<asp:Button ID="btnCalcPrice" runat="server"
onclick="btnCalcPrice_Click"
Text="Calc." />
</p>

Lorsqu'un utilisateur clique sur le bouton, le composant WebPart effectue une publication (postback) afin d'exécuter l'événement (ici, le calcul du coût de produit). Ce qui est probablement plus intéressant que le code de la figure 4, qui est globalement assez simple, est la manière dont le composant WebPart déclenche ce code dans le composant WebPart réel. Étant donné que tout ce que nous avons fait, c'est créer un contrôle utilisateur ASM pour notre composant WebPart qui inclut une apparence et du code-behind, la structure du projet contient toujours le composant WebPart réel qui doit déclencher ce contrôle. Pour cela, Visual Studio crée une chaîne nommée _ascxPath, qui représente le chemin d'accès au contrôle utilisateur ASCX qui se trouve dans la hiérarchie de dossiers SharePoint 2010. Remarquez également que dans la méthode CreateChildControls, une instance d'un contrôle est créée et prend pour valeur le chemin d'accès au contrôle utilisateur (à l'aide de la méthode LoadControl). Elle est ensuite ajoutée à la collection Controls à l'aide de la méthode Add. Cela permet au composant WebPart de déclencher le contrôle utilisateur ASP à l'intérieur du composant WebPart dans SharePoint. La figure 5 illustre le code en question.

Figure 4 Code source de ProductInfoUserControl.ascx.cs

using System;
using System;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Collections.Generic;
using System.Data;
namespace SampleWebPartProject.ProductInfo
{
public partial class ProductInfoUserControl : UserControl
{
double tax = .11;
double totalCost = 0.0;
List<Products> lstOfProducts = new List<Products>();
protected void Page_Load(object sender, EventArgs e)
{
generateProductList();
}
private void generateProductList()
{
lstOfProducts.Add(new Products()
{ strName = "Helmet", strDescr = "Hockey helmet.", strSKU =
"KLSONHELMT1224", dblPrice = 59.00, intQuantity = 28 });
lstOfProducts.Add(new Products()
{ strName = "Skates", strDescr = "Hockey skates.", strSKU =
"SKATWOKSH0965", dblPrice = 438.00, intQuantity = 88 });
lstOfProducts.Add(new Products()
{ strName = "Stick", strDescr = "Composite hockey stick.",
strSKU = "STIK82910JJKS", dblPrice = 189.99, intQuantity =
35 });
lstOfProducts.Add(new Products()
{ strName = "Elbow Pads", strDescr = "Hockey elbow pads.",
strSKU = "ELBOP563215NN", dblPrice = 34.00, intQuantity =
12 });
lstOfProducts.Add(new Products()
{ strName = "Knee Pads", strDescr = "Hockey knee pads.",
strSKU = "KPDS7827NNJS1", dblPrice = 47.99, intQuantity =
44 });
}
protected void btnCalcPrice_Click(object sender, EventArgs e)
{
double dblCost = 0;
string strPrice = "";
if (dropdwnProducts.SelectedValue == "Helmet")
{
dblCost = lstOfProducts[0].dblPrice;
totalCost = dblCost + (dblCost * tax);
System.Math.Round(totalCost, 2);
strPrice = "$" + totalCost.ToString();
txtbxDescription.Text = lstOfProducts[0].strDescr.
ToString();
txtbxSKU.Text = lstOfProducts[0].strSKU.ToString();
txtbxPrice.Text = strPrice;
txtbxQuantity.Text = lstOfProducts[0].intQuantity.
ToString();
}
else if (dropdwnProducts.SelectedValue == "Skates")
{
dblCost = lstOfProducts[1].dblPrice;
totalCost = dblCost + (dblCost * tax);
System.Math.Round(totalCost, 2);
strPrice = "$" + totalCost.ToString();
txtbxDescription.Text = lstOfProducts[1].strDescr.
ToString();
txtbxSKU.Text = lstOfProducts[1].strSKU.ToString();
txtbxPrice.Text = strPrice;
txtbxQuantity.Text = lstOfProducts[1].intQuantity.
ToString();
}
else if (dropdwnProducts.SelectedValue == "Stick")
{
dblCost = lstOfProducts[2].dblPrice;
totalCost = dblCost + (dblCost * tax);
System.Math.Round(totalCost, 2);
strPrice = "$" + totalCost.ToString();
txtbxDescription.Text = lstOfProducts[2].strDescr.
ToString();
txtbxSKU.Text = lstOfProducts[2].strSKU.ToString();
txtbxPrice.Text = strPrice;
txtbxQuantity.Text = lstOfProducts[2].intQuantity.
ToString();
}
else if (dropdwnProducts.SelectedValue == "Elbow Pads")
{
dblCost = lstOfProducts[3].dblPrice;
totalCost = dblCost + (dblCost * tax);
System.Math.Round(totalCost, 2);
strPrice = "$" + totalCost.ToString();
txtbxDescription.Text = lstOfProducts[3].strDescr.
ToString();
txtbxSKU.Text = lstOfProducts[3].strSKU.ToString();
txtbxPrice.Text = strPrice;
txtbxQuantity.Text = lstOfProducts[3].intQuantity.
ToString();
}
else if (dropdwnProducts.SelectedValue == "Knee Pads")
{
dblCost = lstOfProducts[4].dblPrice;
totalCost = dblCost + (dblCost * tax);
System.Math.Round(totalCost, 2);
strPrice = "$" + totalCost.ToString();
txtbxDescription.Text = lstOfProducts[4].strDescr.
ToString();
txtbxSKU.Text = lstOfProducts[4].strSKU.ToString();
txtbxPrice.Text = strPrice;
txtbxQuantity.Text = lstOfProducts[4].intQuantity.
ToString();
}
}
}
}

Figure 5 Code source de ProductInfo.cs

using System;
using System.ComponentModel;
using System.Runtime.InteropServices;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using Microsoft.SharePoint;
using Microsoft.SharePoint.WebControls;
namespace SampleWebPartProject.ProductInfo
{
public class ProductInfo : WebPart
{
private const string _ascxPath =
@"~/CONTROLTEMPLATES/SampleWebPartProject/ProductInfo/" +
@"ProductInfoUserControl.ascx";
public ProductInfo()
{
}
protected override void CreateChildControls()
{
Control control = this.Page.LoadControl(_ascxPath);
Controls.Add(control);
base.CreateChildControls();
}
protected override void Render(HtmlTextWriter writer)
{
base.RenderContents(writer);
}
}
}

Figure 6 Fichier ProductInfo.webpart XML

<?xml version="1.0" encoding="utf-8"?>
<webParts>
<webPart xmlns="https://schemas.microsoft.com/WebPart/v3">
<metaData>
<type name="SampleWebPartProject.ProductInfo.ProductInfo,
SampleWebPartProject, Version=1.0.0.0, Culture=neutral,
PublicKeyToken=db3a9f914308c42a" />
<importErrorMessage>
$Resources:core,ImportErrorMessage;
</importErrorMessage>
</metaData>
<data>
<properties>
<property name="Title" type="string">
Product Info Web Part</property>
<property name="Description" type="string">Provides some
information about hockey products.</property>
</properties>
</data>
</webPart>
</webParts>

Maintenant que vous avez généré le composant Visual WebPart, vous pouvez le déployer sur votre serveur SharePoint. Lorsque vous avez créé le projet, vous l'avez configuré de façon à être associé à une instance de serveur en particulier. Il en découle l'existence de certaines tâches de programmation qui associent le code que vous venez d'écrire au serveur SharePoint. Si vous examinez les fichiers dans l'Explorateur de solutions, vous constaterez la présence de plusieurs fichiers XML qui contribuent à cette intégration. Par exemple, le fichier Feature.xml (voir le code suivant) fournit une définition de la fonctionnalité. On observe dans le code XML auquel le fichier fait référence quelques autres fichiers XML qui donnent également des informations spécifiques sur le composant WebPart. On voit ici que Elements.xml et ProductInfo.webpart sont référencés :

<?xml version="1.0" encoding="utf-8"?>
<Feature xmlns="https://schemas.microsoft.com/sharepoint/" 
Id="416172c1-cfa7-4d7a-93ba-fe093b037fab" 
ImageUrl="" Scope="Site" Title="SampleWebPartProject Feature1">
  <ElementManifests>
    <ElementManifest Location="ProductInfo\Elements.xml" />
    <ElementFile Location="ProductInfo\ProductInfo.webpart" />
  </ElementManifests>

Elements.xml fournit des informations sur les principaux assemblys inclus dans la fonctionnalité et ProductInfo.webpart définit les métadonnées pour le composant WebPart, telles que le titre et la description. Par exemple, la figure 6 illustre les propriétés Title et Description par défaut. Vous pouvez modifier ces propriétés afin de vous assurer que les métadonnées de composant WebPart exposées dans la Galerie de composants WebPart sont intuitives et significatives. Dans le cas de ce composant WebPart, vous souhaiterez sans doute renommer le titre « Composant WebPart d'informations de produit » et la description « Composant WebPart qui fournit des informations et une tarification de produit calculée ».

Figure 7 Composant WebPart sur la page Composants WebPart

Il existe d'autres fichiers de configuration XML. Si vous débutez dans le développement SharePoint, je vous conseille d'examiner chacun de ces fichiers dans le projet afin d'en mieux comprendre le rôle. Passons maintenant au déploiement du composant WebPart sur votre serveur SharePoint.

Déploiement du projet de composant Visual Web Part

Avant SharePoint 2010, Stsadm, outil d'administration en ligne de commande, était couramment utilisé pour déployer des applications sur SharePoint. Il n'est plus nécessaire de recourir à cet outil dans Visual Studio 2010 (et grâce à l'introduction de Windows PowerShell, mais ce sujet mérite un article à part entière). Étant donné que votre projet entretient déjà une relation avec votre serveur SharePoint et que l'association a un niveau d'approbation défini, il vous suffit de cliquer avec le bouton droit sur le projet et de sélectionner l'option Générer, de vous assurer que la génération de la solution réussit, puis de cliquer avec le bouton droit et de sélectionner l'option Déployer. Bien entendu, vous pouvez également utiliser la touche F5 lors du débogage de solutions SharePoint. Ce faisant, l'expérience de débogage inclut des étapes telles que l'attachement au processus approprié et la réinitialisation des services Internet (IIS).

Une fois le composant WebPart déployé, vous devez ouvrir votre site SharePoint et créer une page de composants WebPart. Si vous avez appuyé sur la touche F5 pour déboguer votre application, la page Créer un composant WebPart est appelée par défaut. Sinon, cliquez sur Afficher tout le contenu du site, puis cliquez sur Créer. Cliquez sur l'option Pages de composants WebPart, puis spécifiez les informations demandées concernant cette page de composants WebPart. Par exemple, spécifiez un nom et un modèle de disposition pour la page. Après avoir entré ces informations, cliquez sur Créer pour que SharePoint crée votre page de composants WebPart.

Maintenant, vous devez ajouter le composant Visual Web Part que vous avez créé et déployé sur le serveur. Pour cela, naviguez jusqu'à la page de composants WebPart, cliquez sur Actions du site, puis sur Modifier la page. Cliquez sur la zone de composants WebPart dans laquelle vous souhaitez placer le composant Visual Web Part, cliquez sur l'onglet Insérer, puis sur Composant WebPart.

Une fois ces opérations terminées, SharePoint expose plusieurs catégories de composants WebPart que vous pouvez parcourir afin de sélectionner un composant WebPart spécifique à ajouter à la zone de composants WebPart sélectionnée sur la page. Naviguez jusqu'à la catégorie Personnalisé et, dans le volet Composants WebPart, vous verrez le composant WebPart que vous avez créé et déployé. Si vous avez implémenté le code dans cet article, cliquez sur le composant WebPart ProductInfo, puis cliquez sur le bouton Ajouter.

Le composant WebPart est maintenant ajouté à la zone de composants WebPart sur la page de composants WebPart, illustrée à la figure 7. À ce stade, vous pouvez configurer les options de composants WebPart par le biais du volet Options ou simplement accepter les options par défaut et cliquer sur Arrêter la modification.

Plongez dans le développement SharePoint

Pour les développeurs SharePoint, Visual Studio 2010 procure non seulement une suite d'outils natifs, mais également une opportunité exceptionnelle de se plonger dans le monde du développement SharePoint. Je vous conseille vivement d'étudier ces outils. Il existe d'excellentes options pour les développeurs qui aiment disposer d'un contrôle étroit sur leur code et pour ceux qui apprécient l'expérience de conception pour la génération et le déploiement de solutions performantes dans SharePoint.

Steve Fox est développeur technique en chef auprès de l'équipe de développement des plateformes chez Microsoft. Il travaille en grande partie avec des clients sur des aspects liés au développement Office et SharePoint. Il a publié plusieurs articles et ouvrages et participe régulièrement à des conférences sur le développement dans le monde entier.