Tools in Visual Studio 2010 für die SharePoint-Entwicklung

Entwickler schreckten immer ein wenig vor SharePoint-Entwicklung zurück, weil sie den Eindruck hatten, dass die Entwicklung für diese Plattform umständlich ist und ihre Kenntnisse übersteigt. Die Entwicklercommunity war auch geteilter Meinung über die zu verwendenden Tools. So verwendeten beispielsweise einige Entwickler eine Kombination aus Klassenbibliotheken, manuellen Projektordnern mit XML-Konfigurationsdateien und Ausgabeereignissen nach dem Build, um Features und Lösungen für SharePoint zu generieren. Andere Entwickler haben STSDEV, ein Communitytool, oder Visual Studio-Erweiterungen für Windows SharePoint Services (VSeWSS) verwendet, um verschiedene Anwendungen und Lösungen zu erstellen und auf SharePoint bereitzustellen. Entwicklern standen mit anderen Worten zahlreiche Methoden zur Verfügung, um Features und Lösungspakete auf SharePoint bereitzustellen. Ungeachtet dieser Herausforderungen ist die SharePoint-Entwicklercommunity inzwischen sehr umfangreich - etwa 600.000 Entwickler - und wächst weiterhin. Visual Studio 2010 bewegt sich in die richtige Richtung und bietet Entwicklern mit den neuen, im Paket enthaltenen SharePoint-Tools einen hervorragenden Einstieg in die SharePoint-Entwicklung.

SharePoint 2010 ist ein größerer Schritt nach vorne als Entwicklungsplattform, nicht nur wegen der vielen Features, die die Plattform unterstützt, sondern auch weil bedeutende Investitionen in die Toolsammlung erfolgten, die den Entwicklungsprozess produktiver und für Entwickler sämtlicher Qualifikationsniveaus zugänglicher machen sollen. Die beiden wichtigsten Entwicklertools für SharePoint 2010 sind SharePoint Designer 2010 und Visual Studio 2010. (Die ergänzenden Tools für Designer finden sich in der Expression-Suite.) Dieser Artikel wirft einen ersten Blick auf die SharePoint 2010-Entwicklung, stellt die SharePoint-Tools in Visual Studio 2010 vor (einschließlich eines Vorgeschmacks auf die neuen Projektvorlagen) und illustriert anhand eines Beispiels, wie ein visuelles Webpart erstellt und bereitgestellt wird.

SharePoint-Tools in Visual Studio 2010

In Visual Studio 2010 gibt es eine Reihe von Bereichen, die für SharePoint-Entwickler interessant sind. Zum einen sind im Paket SharePoint-Vorlagen enthalten, sodass Sie sofort mit der Lösungsentwicklung loslegen können. Weiterhin wurden die Tools nach dem Windows SharePoint Package (WSP)-Packagingstandard standardisiert, sodass Visual Studio eine Lösung, die in SharePoint importiert oder bereitgestellt wird, als Lösungspaket behandelt. Außerdem werden mit den SharePoint-Tools in Visual Studio 2010 einige wertvolle Bereitstellungs- und Packagingfeatures, wie Lösungszurückziehung und benutzerdefinierte Bereitstellungskonfigurationen, ausgeliefert. Und zu guter Letzt bietet der neue SharePoint Explorer eine Sicht auf native und benutzerdefinierte Artefakte (z. B. Listen und Workflows), die auf Ihrem SharePoint-Server vorhanden sind. Dies ist natürlich nur eine kurze Auflistung der Features, die eine wesentliche Erweiterung der Visual Studio-Tools mit dem Ziel repräsentieren, von der Community angenommen zu werden und es SharePoint-Entwicklern einfacher zu machen, in die eigentliche Arbeit einzusteigen.

Erwähnenswert sind auch einige der SharePoint 2010-Verbesserungen, die sich ganz sicher auch im Rahmen von Visual Studio 2010 nutzen lassen. So ermöglicht beispielsweise das neue Client-Objektmodell den Zugriff auf SharePoint-Objekte über eine referenzierte DLL statt über Webdienstaufrufe. (In SharePoint 2007 greifen Sie auf SharePoint-Listendaten beispielsweise mithilfe eines ASP.NET-Webdiensts zu.) Und LINQ für SharePoint überträgt die Leistungsfähigkeit von LINQ auf SharePoint, wodurch Sie beispielsweise Listen als stark typisierte Objekte behandeln können. Weiterhin wird Silverlight (insbesondere in Kombination mit dem Client-Objektmodell) in SharePoint2010 nativ unterstützt. Sie müssen sich also nicht mehr mit web.config abplagen, um mit entsprechenden Entwicklungen beginnen zu können. Und Lösungen in einer Sandbox bieten ebenfalls eine Möglichkeit, SharePoint-Webparts zu erstellen und auf einer Site bereitzustellen, ohne dass dazu ein Administratoreingriff erforderlich ist. Das heißt, Sie können ein Webpart auf einer SharePoint-Site bereitstellen und im Kontext dieser Site entweder in einer Instanz von SharePoint vor Ort oder unter Verwendung der gehosteten SharePoint-Version in der Cloud ausführen. Externe Datenlisten schließlich reduzieren die Interaktion mit Line-of-Business-Systemen auf einen reinen Lese-/Schreibvorgang. Dies mag unbedeutend erscheinen, doch ist dies wegen der Toolunterstützung, mit der Sie Line-of-Business-Integrationen schnell und effizient erstellen können, ein riesiger Schritt nach vorne. Für jede dieser Innovationen in SharePoint 2010 bietet Visual Studio 2010 professionellen Entwicklern ein gewisses Maß an Unterstützung, sei es über Projektvorlagen oder APIs. Wenn es einen Zeitpunkt für die Aufnahme der SharePoint-Entwicklung gibt, so ist er jetzt gekommen.

Entwickeln eines visuellen Webpartprojekts

Eines der gängigsten von Entwicklern in SharePoint erstellten und bereitgestellten Artefakte ist das Webpart. Dies macht Sinn, weil Webparts zu den wichtigsten Bausteinen für SharePoint gehören. Weil SharePoint auf ASP.NET aufbaut, übernimmt das Webpart wichtige Features von der ASP.NET-Webpartarchitektur.

Eine der neuen Projektvorlagen in Visual Studio 2010 ist die Visual Web Part-Projektvorlage, mit der Entwickler ein Webpart, das in SharePoint bereitgestellt werden kann, visuell gestalten können. Wenn SharePoint für Sie Neuland ist, ist dies eine hervorragende Möglichkeit, in die Erstellung benutzerdefinierter Anwendungen für SharePoint 2010 einzusteigen. Das hier gezeigte visuelle Webpart enthält eigenständigen Code, der Produktkosten berechnet und Informationen auf einer einfachen Webpart-Oberfläche auflistet.

Abbildung 1 Neue SharePoint-Projektvorlagen

Abbildung 2 Entwurfsansicht eines visuellen Webparts

Stellen Sie sicher, dass Sie die Beta 2 von Visual Studio 2010 sowie die Beta 2 von SharePoint 2010 unter 64-Bit-Windows Server 2008 installiert haben. Öffnen Sie Visual Studio 2010, klicken Sie auf Datei, Neues Projekt), und navigieren Sie im Abschnitt Installierte Vorlagen zum SharePoint-Knoten. Abbildung 1 zeigt die verschiedenen verfügbaren Projektvorlagen. Die Projektvorlage Import VSeWSS bietet beispielsweise einen Upgradepfad von Ihren aktuellen VSeWSS-Projekten, die Workflowvorlagen ermöglichen die Erstellung und Bereitstellung von Workflowprojekten in SharePoint, die Vorlage Site Definition stellt eine Infrastruktur auf Siteebene zur Verfügung, die Sie ausbauen und bereitstellen können, und Import SharePoint Solution Package ist die Vorlage zum Importieren von WSPs zu erneuten Bereitstellung auf einer lokale Serverinstanz. Wählen Sie für diese Übung die Projektvorlage Visual Web Part aus, geben Sie einen Namen (z. B. SampleWebPartProject) und einen Speicherort für Ihr Projekt an, und klicken Sie dann auf OK.

Nach dem Erstellen eines Projekts erstellt Visual Studio 2010 eine Reihe von Standarddateien. Erweitern Sie die Projektnoten im Projektmappen-Explorer, um die Dateien anzuzeigen. Die wichtigsten Dateien, mit denen Sie in diesem Artikel arbeiten, befinden sich im Knoten SampleWebPartProject. Sie sehen, dass das visuelle Webpart standardmäßig den Namen VisualWebPart1 hat. Um dies zu ändern, klicken Sie mit der rechten Maustaste im Projektmappen-Explorer auf den Knoten VisualWebPart1, wählen Sie Umbenennen aus, und geben Sie einen neuen Namen für das Webpart ein.

Sie werden auch bemerken, das im Projektmappen-Explorer, die Knoten Features und Paket enthalten sind. Dies sind neue Infrastrukturelemente in Visual Studio 2010, die eine SharePoint-Lösung mithilfe eines SharePoint-Features in einem Paket kombinieren. Für Entwickler, für die SharePoint Neuland ist: Ein Feature organisiert Ihre Anwendung so, dass sie von SharePoint „verstanden“ wird. Features können in SharePoint auf Site- oder Webebene bereitgestellt werden. Beispiel: Ein Feature wird mit einer Reihe von XML-Konfigurationsdateien strukturiert und referenziert (je nach Vertrauensebene Ihrer Anwendung) auch die Assembly aus dem Globalen Assemblycache (GAC). Genauer gesagt, hat jedes Feature in der SharePoint-Ordnerhierarchie seinen eigenen Ordner, und die Konfigurationsdateien befinden sich in diesem Ordner und stellen die für das Feature erforderlichen Metadaten zur Verfügung. Das Paket enthält Features und andere Ressourcen und wird verwendet, wenn Sie Lösungen in SharePoint bereitstellen. In dem Paket wird auch der Assemblybereitstellungsort festgelegt. Visual Studio 2010 enthält einen Paketdesigner, der die Anzeige und Verwaltung von Paketen erheblich vereinfacht. Wenn Sie auf den Knoten Paket doppelklicken, wird der Designer geöffnet. Die Designer bietet die Möglichkeit, Features aus Ihrem bereitstellungsfähigen Paket hinzuzufügen und zu entfernen. Dieser Designer ist ein wichtiger Schritt im Hinblick darauf, Entwickler bei der Anpassung ihrer SharePoint-Lösungen durch Hinzufügen von Features zu unterstützen.

Wechseln Sie zur Projektmappen-Explorer-Ansicht zurück, klicken Sie mit der rechten Maustaste auf die Datei ProductInfoUserControl.ascx, und wählen Sie dann View in Designer (In Designer anzeigen) aus. Nun wird eine Ansicht geöffnet, in der Sie Steuerelemente mit Drag & Drop aus der Toolbox auf die Webpart-Designeroberfläche ziehen und ablegen können. Sie werden drei Ansichten finden: Design, Split (Geteilt) und Code. In diesem Beispiel habe ich einen Titel und einige Steuerelemente, einschließlich Textfelder und eine Schaltfläche zur Berechnung der Kosten des Produkts, hinzugefügt. Außerdem habe ich Bezeichnungen für die Steuerelemente eingegeben, die zur Seite hinzugefügt wurden (siehe Abbildung 2).

Nachdem Sie das visuelle Webpartlayout fertig gestellt haben, können Sie der Schaltfläche Ereignishandler hinzufügen. Werfen wir jedoch zuvor noch einen Blick auf den Quellcode für das visuelle Webpart. Wie Sie dem Codeauszug in Abbildung 3 entnehmen können, fügt Visual Studio der Oberfläche einige automatische Stile in Form von CSS-Syntax hinzu. Sie können auch die tatsächlichen Steuerelemente (und im Fall des Dropdown-Listenfelds die darin enthaltenen Elemente) sehen, die die Oberfläche bilden. Beachten Sie, dass ich zur besseren Übersichtlichkeit die Anweisungen entfernt habe, die automatisch generiert und im oberen Teil des Quellcodes eingesetzt werden.

Doppelklicken Sie auf die Schaltfläche, um Ereignishandler zum Webpart hinzuzufügen. Das Code-Behind-Fenster wird geöffnet. Zum ASCX-Steuerelementdesign wird auch ein onClick-Ereignis hinzugefügt. So gibt es zum Beispiel in Abbildung 3 das in btnCalcPrice enthaltene Ereignis onclick="btnCalcPrice_Click". Der in Abbildung 4 aufgelistete Code-Behind enthält Beispielcode, mit dem Sie den Preis des im Listenfeld ausgewählten Produkts berechnen können. Die wichtigsten Bestandteile des Codes sind die Variablen auf Klassenebene (die double-Variablen), die für die Methode stehen, die ich zum Berechnen der Produktkosten verwende, die Auflistung List of Products (Produktliste) (die eine Reihe von Products-Objekten enthält, die zum Listenfeld hinzugefügt werden) und das Ereignis btnCalcPrice_Click. Wenn die Seite in SharePoint geladen wird, ruft der Code die Methode generateProductList auf, die das Listenfeld füllt. Das Ereignis btnCalcPrice_Click berechnet dann die Kosten des vom Benutzer ausgewählten Produkts und zeigt das Ergebnis auf der Oberfläche im Listenfeld an.

Abbildung 3 Quellcode für ProductInfoUserControl.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:&nbsp;&nbsp;
<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>

Wenn ein Benutzer auf die Schaltfläche klickt, führt das Webpart ein Postback aus, um das Ereignis auszuführen, in diesem Fall die Berechnung der Produktkosten. Viel interessanter als der Code in Abbildung 4, der ziemlich einfach ist, ist die Art und Weise, wie das Webpart diesen Code im eigentlichen Webpart verwendet. Weil wir ein ASP-Benutzersteuerelement für unser Webpart erstellt haben, das einen Skin und Code-Behind enthält, enthält die Projektstruktur immer noch das eigentliche Webpart, das dieses Steuerelement verwenden muss. Dazu erstellt Visual Studio einen String namens _ascxPath, der den Pfad zu dem ASCX-Benutzersteuerelement repräsentiert, das sich in der SharePoint 2010-Ordnerhierarchie befindet. Sie sehen außerdem, dass in der CreateChildControls-Methode eine Instanz eines Steuerelements erstellt und auf den Pfad zum Benutzersteuerelement eingestellt wird (mithilfe der LoadControl-Methode). Es wird dann mithilfe der Add-Methode zur Controls-Auflistung hinzugefügt. Dadurch kann das Webpart das ASP-Benutzersteuerelement innerhalb des Webparts in SharePoint verwenden. Abbildung 5 zeigt den Code.

Abbildung 4 Quellcode für 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();
}
}
}
}

Abbildung 5 Quellcode für 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);
}
}
}

Abbildung 6 ProductInfo.webpart-XML-Datei

<?xml version="1.0" encoding="utf-8"?>
<webParts>
<webPart xmlns="http://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>

Nachdem wir jetzt das visuelle Webpart erstellt haben, können Sie es auf Ihrem SharePoint-Server bereitstellen. Bei der Erstellung des Projekts haben Sie es so konfiguriert, dass es einer bestimmten Serverinstanz zugeordnet wird. Infolgedessen wurde ein wenig programmatische „Näharbeit“ geleistet, die den soeben beschriebenen Code mit dem SharePoint-Server verbindet. Wenn Sie die Dateien im Projektmappen-Explorer untersuchen, werden Sie eine Reihe von XML-Dateien sehen, die bei dieser Integration helfen. So enthält zum Beispiel die Datei Feature.xml (siehe Code unten) eine Definition des Features. Sie sehen in der XML-Datei, dass darin eine Reihe anderer XML-Dateien referenziert wird, die ebenfalls spezifische Informationen über das Webpart enthalten. Hier sehen Sie, dass Elements.xml und ProductInfo.webpart referenziert werden:

<?xml version="1.0" encoding="utf-8"?>
<Feature xmlns="http://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 enthält Informationen über die Kernassemblys, die im Feature enthalten sind, während ProductInfo.webpart Metadaten zum Webpart, wie seinen Titel und seine Beschreibung, definiert. Abbildung 6 zeigt beispielsweise die Standardeigenschaften für Titel und Beschreibung. Sie können diese Eigenschaften ändern, um sicherzustellen, dass die im Webpartkatalog angezeigten Webpartmetadaten anschaulich und aussagekräftig sind. Im Fall dieses Webparts könnten Sie beispielsweise den Titel in „Produktinformationswebpart“ und die Beschreibung in „Webpart zur Berechnung von Produktpreisen und -daten“ ändern.

Abbildung 7 Webpart auf Webpartseite

Es gibt noch andere XML-Konfigurationsdateien, und wenn für Sie die SharePoint-Entwicklung Neuland ist, würde ich empfehlen, jede einzelne im Projekt zu untersuchen, um ihren Zweck besser zu verstehen. Gehen wir jetzt zur Bereitstellung des Webparts auf Ihrem SharePoint-Server über.

Bereitstellen des visuellen Webpartprojekts

Vor SharePoint 2010 wurde meistens Stsadm, ein Administrationstool für die Befehlszeile, verwendet, um Anwendungen in SharePoint bereitzustellen. Das hat sich mit Visual Studio 2010 (und mit der Einführung von Window PowerShell, doch verdient dieses Thema seinen eigenen Artikel) erledigt. Weil Ihr Projekt bereits eine Beziehung zum SharePoint-Server und die Zuordnung eine definierte Vertrauensebene hat, müssen Sie lediglich mit der rechten Maustaste auf das Projekt klicken und Build auswählen, überprüfen, dass die Lösung tatsächlich erstellt wird, und dann mit der rechten Maustaste klicken und Bereitstellen auswählen. Natürlich funktioniert auch die F5-Taste, wenn Sie Ihre SharePoint-Lösungen debuggen. In diesem Fall beinhaltet der Debugvorgang auch Schritte wie Anfügen an den geeigneten Prozess und Zurücksetzen von IIS.

Nachdem Sie das Webpart erfolgreich bereitgestellt haben, müssen Sie die SharePoint-Site öffnen und eine neue Webpartseite erstellen. Wenn Sie zum Debuggen Ihrer Anwendung F5 gedrückt haben, wird Webpartseite erstellen automatisch aufgerufen. Klicken Sie andernfalls auf Alle Websiteinhalte einblenden und anschließend auf Erstellen. Klicken Sie auf die Option Webpartseite, und geben Sie die über diese spezielle Webpartseite abgefragten Informationen ein. Geben Sie beispielsweise einen Namen und Layoutvorlage für die Seite an. Wenn Sie nach Eingabe dieser Informationen auf Erstellen klicken, erstellt SharePoint Ihre Webpartseite.

Jetzt müssen Sie das erstellte und auf dem Server bereitgestellte visuelle Webpart hinzufügen. Navigieren Sie dazu zur Webpartseite, klicken Sie auf Siteaktionen und dann auf Seite bearbeiten. Klicken Sie in den Bereich des Webparts, in dem das visuelle Webpart platziert werden soll, klicken Sie auf die Registerkarte Einfügen, und klicken Sie dann auf dieser Registerkarte auf Webpart.

Anschließend zeigt SharePoint eine Reihe von Webpartkategorien an, die Sie durchsuchen können, um ein Webpart auszuwählen, das dem auf der Seite ausgewählten Webpartbereich hinzugefügt werden soll. Wenn Sie zur Kategorie Benutzerdefiniert navigieren, sehen Sie im Bereich Webparts das erstellte und bereitgestellte visuelle Webpart. Wenn Sie den Code genau wie in diesem Artikel eingegeben haben, klicken Sie auf das Webpart ProductInfo und dann auf die Schaltfläche Hinzufügen.

Das Webpart wird jetzt zum Webpartbereich auf der Webpartseite hinzugefügt (siehe Abbildung 7). Jetzt können Sie die Webpartoptionen im Bereich Tools konfigurieren oder die Standardoptionen akzeptieren und auf Bearbeitung beenden klicken.

Steigen Sie in die SharePoint-Entwicklung ein

Für SharePoint-Entwickler bietet Visual Studio 2010 nicht nur eine Reihe nativer Tools, sondern auch eine hervorragende Gelegenheit, in die SharePoint-Entwicklung einzusteigen. Ich empfehle wirklich, dass Sie diese Tools ausprobieren. Darunter finden sich einige hervorragende Möglichkeiten für Entwickler, die die absolute Kontrolle über ihren Code wünschen, aber auch für solche, die gerne experimentieren, um großartige Lösungen zu erstellen und in SharePoint bereitzustellen.

Steve Fox ist leitender Technologieexperte im Entwickler- und Plattformteam bei Microsoft. Die meiste Zeit arbeitet er zusammen mit Kunden an Office- und SharePoint-Entwicklungen. Fox hat eine Reihe von Büchern und Artikeln veröffentlicht und spricht regelmäßig auf Entwicklerkonferenzen weltweit.