Fabian´s Blog [SharePoint MVP]

State Service Application in SharePoint 2010 erstellen

Fabian Moritz — Tue, 15 Jun 2010 05:39:58 GMT

Sollte der Versuch einen SharePoint Workflow über die Websiteoberfläche zu erzeugen in einer InfoPath Fehlermeldung münden, liegt das daran, dass der State Service nicht aktiviert ist. SharePoint wartet in diesem Fall mit folgender Fehlermeldung auf:

The form cannot be rendered. This may be due to a misconfiguration of the Microsoft SharePoint Server State Service. For more information, contact your server administrator.

Leider sucht man in der Verwaltung der Managed Service Applications nur vergeblich nach einer Schaltfläche zur Erzeugung einer State Service Application. Aus diesem Grund bleiben hierfür nur noch zwei Alternativen offen:

Configuration Wizzard. Das halte ich für wenig optimal.
PowerShell. Die bessere Variante!

Um den State Service via PowerShell zu aktivieren kann man viel folgt vorgehen.

SharePoint 2010 Management Shell starten
Neue Service Application erzeugen: $myApp = New-SPStateServiceApplication -Name “State Service Application”
State Service Datenbank erzeugen und mit der Application verbinden: New-SPStateServiceDatabase -Name “SharePoint_StateService” -ServiceApplication $myApp
Application Proxy erzeugen und zur Stage Service Application assoziieren: New-SPStateServiceApplicationProxy -Name “State Service Application Proxy” -ServiceApplication $myApp –DefaultProxyGroup

Hier noch einmal der komplette Befehl:

Die State Service Application ist danach in der Liste der Managed Service Applications zu finden und kann hierüber ggf. auch wieder entfernt werden.

Microsoft SharePoint Konferenz 2010 AUT – Präsentationen und Demos

Fabian Moritz — Thu, 10 Jun 2010 15:49:54 GMT

Zwei Tage Microsoft SharePoint Konferenz 2010 in Wien neigen sich dem Ende. Ein Event auf österreichischem Boden war für mich Premiere. An dieser Stellen noch einmal vielen Dank an alle Teilnehmer für die vollen Räume während meiner Sessions und auch die netten Gespräche danach. Besonders die hohe Resonanz des Office Business Applications Tracks war für mich sehr überraschend!

Hier die Präsentationen sowie die Demos meiner beiden Vorträge:

Bei Feedback oder Fragen einfach melden!

Windows SharePoint Services 3.0 vs. SharePoint Foundation 2010 Objektmodell

Fabian Moritz — Wed, 12 May 2010 12:12:39 GMT

Heute wird SharePoint 2010 gelauncht – eine gute Gelegenheit die beiden Programmierschnittstellen mal gegenüberzustellen. In dem Objektmodell von SharePoint Foundation 2010 hat sich in Vergleich zur Vorversion (Windows SharePoint Services 3.0) einiges getan! Die Anzahl der Klassen, Enums und Interfaces wurde nahezu verdoppelt. Hier die Zahlen:

	WSS 3.0	SPF 2010
Klassen	2727	6134
Enums	450	820
Interfaces	85	221
Namespaces	32	78

Auch die Namensräume wurden mit SharePoint Foundation mehr als verdoppelt; hier eine Liste der Namespaces von SharePoint Foundation im Vergleich zu WSS:

Microsoft.BusinessData
Microsoft.SharePoint
Microsoft.SharePoint.Administration
Microsoft.SharePoint.Administration.AccessControl
Microsoft.SharePoint.Administration.Backup
Microsoft.SharePoint.Administration.Claims
Microsoft.SharePoint.Administration.Health
Microsoft.SharePoint.ApplicationPages.Calendar
Microsoft.SharePoint.ApplicationPages.Calendar.Exchange
Microsoft.SharePoint.ApplicationPages.PickerQuery
Microsoft.SharePoint.ApplicationPages.WebControls
Microsoft.SharePoint.ApplicationRuntime
Microsoft.SharePoint.Applications.GroupBoard
Microsoft.SharePoint.Applications.GroupBoard.MobileControls
Microsoft.SharePoint.Applications.GroupBoard.Utilities
Microsoft.SharePoint.Applications.GroupBoard.WebControls
Microsoft.SharePoint.Applications.GroupBoard.WebPartPages
Microsoft.SharePoint.BusinessData.Administration
Microsoft.SharePoint.BusinessData.Infrastructure
Microsoft.SharePoint.BusinessData.Infrastructure.Collections
Microsoft.SharePoint.BusinessData.MetadataModel
Microsoft.SharePoint.BusinessData.MetadataModel.Collections
Microsoft.SharePoint.BusinessData.MetadataModel.Constants
Microsoft.SharePoint.BusinessData.MetadataModel.Dynamic
Microsoft.SharePoint.BusinessData.MetadataModel.Static
Microsoft.SharePoint.BusinessData.MetadataModel.Static.DataAccess
Microsoft.SharePoint.BusinessData.Offlining
Microsoft.SharePoint.BusinessData.Parser
Microsoft.SharePoint.BusinessData.Runtime
Microsoft.SharePoint.BusinessData.SharedService
Microsoft.SharePoint.BusinessData.SharedService.Structs.ExtensionMethods
Microsoft.SharePoint.BusinessData.SystemSpecific
Microsoft.SharePoint.BusinessData.SystemSpecific.Db
Microsoft.SharePoint.BusinessData.SystemSpecific.DotNetAssembly
Microsoft.SharePoint.BusinessData.SystemSpecific.Wcf
Microsoft.SharePoint.BusinessData.SystemSpecific.WebService
Microsoft.SharePoint.BusinessData.Upgrade
Microsoft.SharePoint.Calculation
Microsoft.SharePoint.Client
Microsoft.SharePoint.CoordinatedStreamBuffer
Microsoft.SharePoint.Deployment
Microsoft.SharePoint.Diagnostics
Microsoft.SharePoint.Diagnostics.ULSEventTemplates
Microsoft.SharePoint.DirectorySoap
Microsoft.SharePoint.Dsp
Microsoft.SharePoint.EmailIntegration
Microsoft.SharePoint.Help
Microsoft.SharePoint.Help.Constants
Microsoft.SharePoint.Help.Search
Microsoft.SharePoint.IdentityModel
Microsoft.SharePoint.JSGrid
Microsoft.SharePoint.JsonUtilities
Microsoft.SharePoint.Library
Microsoft.SharePoint.Meetings
Microsoft.SharePoint.Metabase
Microsoft.SharePoint.MobileControls
Microsoft.SharePoint.MobileMessage
Microsoft.SharePoint.Navigation
Microsoft.SharePoint.RBSWrapper
Microsoft.SharePoint.SoapServer
Microsoft.SharePoint.StsAdmin
Microsoft.SharePoint.Upgrade
Microsoft.SharePoint.UserCode
Microsoft.SharePoint.Utilities
Microsoft.SharePoint.Utilities.Cab
Microsoft.SharePoint.Utilities.SimpleParsers
Microsoft.SharePoint.Utilities.SqlTrace
Microsoft.SharePoint.Utilities.Syndication
Microsoft.SharePoint.Utilities.ThemingParser
Microsoft.SharePoint.Utilities.Win32
Microsoft.SharePoint.WebControls
Microsoft.SharePoint.WebPartPages
Microsoft.SharePoint.WebPartPages.Communication
Microsoft.SharePoint.Win32
Microsoft.SharePoint.Workflow
Microsoft.SharePoint.WorkflowUtil
Microsoft.Xslt

Stellenangebot: ASP.NET / SharePoint-Entwickler gesucht

Fabian Moritz — Mon, 10 May 2010 09:35:45 GMT

Wir sind mal wieder auf der Suche nach neuen Mitarbeitern für unser Team! Gesucht wird ein ASP.NET bzw. SharePoint-Entwickler mit Projekterfahrung. Wer diese Rolle ausfüllen kann und an spannenden Projekten für namhafte Kunden mitwirken möchte, kann sich mit einer Bewerbung gerne bei uns melden! Weitere Informationen und die offizielle Stellenausschreibung ist auf unserer Firmenwebseite zu finden.

SharePoint 2010 Ribbon anpassen und erweitern

Fabian Moritz — Fri, 07 May 2010 07:05:03 GMT

Eine der wesentlichen neuen Funktionen in SharePoint Foundation 2010 ist die Integration des aus Office 2007 bekannten Ribbons. Die Ribbon-Technologie wurde durchgängig in die SharePoint-Benutzeroberfläche integriert und macht die Arbeit und Interaktion mit SharePoint-Funktionen zukünftig deutlich einfacher. Die Technologie der Ribbons kann auch für eigene Webparts oder benutzerdefinierte Anwendungen genutzt werden. In diesem Artikel möchte ich die Technologie der SharePoint Ribbons vorstellen und beschreiben, wie sich der Ribbon anpassen und um neue Elemente erweitern lässt.

Zunächst ein paar grundsätzliche Worte: Die Ribbon-Technologie basiert auf einem deklarativen Modell. Ribbons werden vollständig via XML beschrieben. Die XML-Definition des Standard-Ribbons befindet sich direkt auf dem SharePoint-Server im Verzeichnis C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\14\TEMPLATE\GLOBAL\XML\CMDUI.XML. Diese Datei beschreibt vollständig die Struktur des SharePoint Standard-Ribbons; wer sich in diese Thematik einarbeiten möchte, sollte unbedingt einen Blick auf diese XML-Datei werfen! Die Hierarchie der Ribbon-Elemente ist stets gleich: Ribbon > Tab > Group > Control. Innerhalb des Control-Elements können unterschiedliche Controls platziert werden; die bekanntesten seiner Vertreter sind der Button, eine Checkbox, ein Dropdown-Feld oder eine Textbox. Beachtet werden sollte, dass der Ribbon es nicht ermöglicht, benutzerdefinierte Steuerelemente einzubetten.

Eigene Ribbons werden mittels eines Element Manifests in die SharePoint-Oberfläche integriert. Das Manifest beginnt mit einem CustomAction-Attribut gefolgt von der Struktur der Ribbon-Elemente. Benutzerdefinierte Elemente können in einen beliebigen Bereich des Ribbons integriert werden; es ist ebenso möglich einen komplett neuen Tab in den Ribbon zu integrieren, wie auch ein einzelnen Button innerhalb einer definierte Gruppe. Die Ribbon-Technologie erlaubt auch die Einbettung von Programmcode. Der Code wird über das SharePoint ECMAScript (JavaScript; JScript) in den Ribbon integriert. Mittels des Client-Objektmodells kann der Ribbon mit Elementen der SharePoint-UI interagieren und so zum Beispiel Dialoge öffnen oder eine Nachricht in der Statusleiste ausgeben. Der Script Code kann direkt über das CommandAction-Attribut im Element Manifest definiert oder einer separaten Datei ausgelagert werden.

So viel zum theoretischen; gehen wir in die Praxis über! In meinem Beispiel möchte ich den allgemeinen Aufbau eines benutzerdefinierten Ribbons erläutern. Das Ergebnis sieht wie folgt aus:

Folgender XML-Block sorgt für die Erzeugung dieses Ribbon:

   1: <?xml version="1.0" encoding="utf-8"?>

   2: <Elements xmlns="http://schemas.microsoft.com/sharepoint/">

   3:   <CustomAction

   4:     Id="FM.Ribbon.Tab"

   5:     Location="CommandUI.Ribbon"

   6:     RegistrationType="List"

   7:     RegistrationId="101">

   8:     <CommandUIExtension>

   9:       <CommandUIDefinitions>

  10:         <CommandUIDefinition Location="Ribbon.Tabs._children">

  11:           <Tab Id="FM.Ribbon.Tab" Title="My Tab" Sequence="101">

  12:             <Scaling Id="FM.Ribbon.Tab.Scaling">

  13:               <MaxSize Id="FM.Ribbon.Tab.Groups.GroupOne.MaxSize"

  14:                        GroupId="FM.Ribbon.Tab.Groups.GroupOne"

  15:                        Size="TwoLarge"/>

  16:               <MaxSize Id="FM.Ribbon.Tab.Groups.GroupOne.MaxSize"

  17:                        GroupId="FM.Ribbon.Tab.Groups.GroupTwo"

  18:                        Size="ThreeMedium"/>

  19:               <Scale Id="FM.Ribbon.Tab.Groups.GroupTwo.Scaling"

  20:                      GroupId="FM.Ribbon.Tab.Groups.GroupOne"

  21:                      Size="ThreeMedium"/>

  22:             </Scaling>

  23:             <Groups Id="FM.Ribbon.Tab.Groups">

  24:               <Group

  25:                 Id="FM.Ribbon.Tab.Groups.GroupOne"

  26:                 Title="Group"

  27:                 Sequence="10"

  28:                 Template="Ribbon.Templates.Large">

  29:                 <Controls Id="FM.Ribbon.Tab.Groups.GroupOne.Controls">

  30:                   <Button

  31:                     Id="FM.Ribbon.Tab.Groups.GroupOne.Buttons.ButtonOne"

  32:                     Command="CustomMessage"

  33:                     Sequence="10"

  34:                     Image16by16="/_layouts/images/SolutionActivate_16x16.png"

  35:                     Image32by32="/_layouts/images/SolutionActivate_32x32.png"

  36:                     LabelText="Button One"

  37:                     TemplateAlias="c1"/>

  38:                   <Button

  39:                     Id="FM.Ribbon.Tab.Groups.GroupOne.Buttons.ButtonTwo"

  40:                     Command="CustomMessage"

  41:                     Sequence="20"

  42:                     Image16by16="/_layouts/images/SolutionDeactivate_16x16.png"

  43:                     Image32by32="/_layouts/images/SolutionDeactivate_32x32.png"

  44:                     LabelText="Button Two"

  45:                     TemplateAlias="c2"/>

  46:                 </Controls>

  47:               </Group>

  48:               <Group

  49:                Id="FM.Ribbon.Tab.Groups.GroupTwo"

  50:                Title="Group"

  51:                Sequence="20"

  52:                Template="Ribbon.Templates.Medium">

  53:                 <Controls Id="FM.Ribbon.Tab.Groups.GroupTwo.Controls">

  54:                   <Button

  55:                     Id="FM.Ribbon.Tab.Groups.GroupTwo.Buttons.ButtonOne"

  56:                     Command="CustomMessage"

  57:                     Sequence="10"

  58:                     Image16by16="/_layouts/images/SolutionActivate_16x16.png"

  59:                     LabelText="Button One"

  60:                     TemplateAlias="c1"/>

  61:                   <Button

  62:                     Id="FM.Ribbon.Tab.Groups.GroupTwo.Buttons.ButtonTwo"

  63:                     Command="CustomMessage"

  64:                     Sequence="20"

  65:                     Image16by16="/_layouts/images/SolutionDeactivate_16x16.png"

  66:                     LabelText="Button Two"

  67:                     TemplateAlias="c2"/>

  68:                   <TextBox

  69:                     Id="FM.Ribbon.Tab.Groups.GroupTwo.TextBox"

  70:                     Sequence="30"

  71:                     Width="180"

  72:                     TemplateAlias="c3"/>

  73:                 </Controls>

  74:               </Group>

  75:             </Groups>

  76:           </Tab>

  77:         </CommandUIDefinition>

  78:         <CommandUIDefinition Location="Ribbon.Templates._children">

  79:           <GroupTemplate Id="Ribbon.Templates.Large">

  80:             <Layout Title="TwoLarge" LayoutTitle="TwoLarge">

  81:               <Section Alignment="Top" Type="OneRow">

  82:                 <Row>

  83:                   <ControlRef DisplayMode="Large" TemplateAlias="c1" />

  84:                 </Row>

  85:               </Section>

  86:               <Section Alignment="Top" Type="OneRow">

  87:                 <Row>

  88:                   <ControlRef DisplayMode="Large" TemplateAlias="c2" />

  89:                 </Row>

  90:               </Section>

  91:             </Layout>

  92:           </GroupTemplate>

  93:         </CommandUIDefinition>

  94:         <CommandUIDefinition Location="Ribbon.Templates._children">

  95:           <GroupTemplate Id="Ribbon.Templates.Medium">

  96:             <Layout Title="ThreeMedium" LayoutTitle="ThreeMedium">

  97:               <Section Alignment="Top" Type="ThreeRow">

  98:                 <Row>

  99:                   <ControlRef DisplayMode="Medium" TemplateAlias="c1" />

 100:                 </Row>

 101:                 <Row>

 102:                   <ControlRef DisplayMode="Medium" TemplateAlias="c2" />

 103:                 </Row>

 104:                 <Row>

 105:                   <ControlRef DisplayMode="Medium" TemplateAlias="c3" />

 106:                 </Row>

 107:               </Section>

 108:             </Layout>

 109:           </GroupTemplate>

 110:         </CommandUIDefinition>

 111:       </CommandUIDefinitions>

 112:       <CommandUIHandlers>

 113:         <CommandUIHandler

 114:           Command="CustomMessage"

 115:           CommandAction="javascript:javascript:alert('Hello from the ribbon');" />

 116:       </CommandUIHandlers>

 117:     </CommandUIExtension>

 118:   </CustomAction>

 119: </Elements>

Jetzt werde ich mich Stück für Stück durch die einzelnen Elemente dieser XML-Struktur durcharbeiten:

   1: <?xml version="1.0" encoding="utf-8"?>

   2: <Elements xmlns="http://schemas.microsoft.com/sharepoint/">

   3:   <CustomAction

   4:     Id="FM.Ribbon.Tab"

   5:     Location="CommandUI.Ribbon"

   6:     RegistrationType="List"

   7:     RegistrationId="101">

CustomAction ist jeweils das Wurzelelement einer Ribbon-Erweiterung. Das Location-Attribut muss auf den Wert CommandUI.Ribbon gesetzt sein; damit bekommt das Element die Möglichkeit, benutzerdefinierte Erweiterungen im Ribbon zu registrieren. Die RegistrationID definiert den Bereich, für den die Erweiterung bereitgestellt wird. Als Bereiche können die BaseType IDs der SharePoint-Elemente angegeben werden; hier einige Beispiele: 100 = Generic List, 101 = Document library, 102 = Survey, 103 = Links, 104 = Announcements etc. Eine vollständige Liste der Template IDs liefert das SDK. In meinem Fall wird der neue Tab im Kontext einer Dokumentenbibliothek bereitgestellt. Der RegistrationType muss auf den Typ List gesetzt werden.

   1: <CommandUIDefinitions>

   2:        <CommandUIDefinition Location="Ribbon.Tabs._children">

   3:          <Tab Id="FM.Ribbon.Tab" Title="My Tab" Sequence="101">

   4:            <Scaling Id="FM.Ribbon.Tab.Scaling">

   5:              <MaxSize Id="FM.Ribbon.Tab.Groups.GroupOne.MaxSize"

   6:                       GroupId="FM.Ribbon.Tab.Groups.GroupOne"

   7:                       Size="TwoLarge"/>

   8:              <MaxSize Id="FM.Ribbon.Tab.Groups.GroupOne.MaxSize"

   9:                       GroupId="FM.Ribbon.Tab.Groups.GroupTwo"

  10:                       Size="ThreeMedium"/>

  11:              <Scale Id="FM.Ribbon.Tab.Groups.GroupTwo.Scaling"

  12:                     GroupId="FM.Ribbon.Tab.Groups.GroupOne"

  13:                     Size="ThreeMedium"/>

  14:            </Scaling>

15:

CommandUIDefinitions ist das wichtigste Element der Ribbon-Erweiterung, weil hierüber der eigentliche Aufbau strukturiert wird. Über das Location-Attribut wird definiert, in welchem Bereich die jeweiligen Erweiterungen integriert werden sollen. Das Ribbon Framework stellt hierbei verschiedene Möglichkeiten bereit. Beispielweise kann ein einzelner Button in eine bestehende Gruppe (z. B. Ribbon.Documents.New.Controls._children) oder ein komplett neuer Tab (Ribbon.Tabs._children) in den obersten Bereich des Ribbon zu platzieren. Die _children-Signatur teilt dem Ribbon mit, das Element unterhalb dieses Bereichs zu integrieren. Eine Liste der möglichen Location-Elemente liefert das SharePoint SDK. Mittels des Sequence-Attributs wird die Position des Controls definiert. Die Tabs werden in 100er, die restlichen Elemente in 10er-Schritten positioniert; damit bleibt für benutzerdefinierte Tabs, Gruppen oder Controls reichlich Platz. Genauere Informationen zur Aufteilung der jeweiligen Controls kann der CMDUI.XML entnommen werden.

Das Tab-Element bildet das oberste Element des Ribbons. Innerhalb dieses Bereichs kann eine Sequenz von Gruppen und Controls aufgebaut werden.

Über das Skalings-Element wird festgelegt, wie sich die Controls bei Größenänderungen des Browsers verhalten. Die Skalierung erfolgt auf Ebene einer Gruppe. Pro Gruppe muss mindestens die MaxSize angegeben werden. Sie definiert die maximale Größe der Controls einer Gruppe. Über das Scale-Element wird die Größe bei reduzierter Skalierung definiert. Als Größenangabe wird das Layout eines GroupTemplates referenziert. Hierüber können acht verschiede Darstellungsmodi definiert werden. Dazu später mehr!

   1: <Groups Id="FM.Ribbon.Tab.Groups">

   2:             <Group

   3:               Id="FM.Ribbon.Tab.Groups.GroupOne"

   4:               Title="Group"

   5:               Sequence="10"

   6:               Template="Ribbon.Templates.Large">

   7:               <Controls Id="FM.Ribbon.Tab.Groups.GroupOne.Controls">

   8:                 <Button

   9:                   Id="FM.Ribbon.Tab.Groups.GroupOne.Buttons.ButtonOne"

  10:                   Command="CustomMessage"

  11:                   Sequence="10"

  12:                   Image16by16="/_layouts/images/SolutionActivate_16x16.png"

  13:                   Image32by32="/_layouts/images/SolutionActivate_32x32.png"

  14:                   LabelText="Button One"

  15:                   TemplateAlias="c1"/>

  16:                 <Button

  17:                   Id="FM.Ribbon.Tab.Groups.GroupOne.Buttons.ButtonTwo"

  18:                   Command="CustomMessage"

  19:                   Sequence="20"

  20:                   Image16by16="/_layouts/images/SolutionDeactivate_16x16.png"

  21:                   Image32by32="/_layouts/images/SolutionDeactivate_32x32.png"

  22:                   LabelText="Button Two"

  23:                   TemplateAlias="c2"/>

  24:               </Controls>

  25:             </Group>

Nach dem Skaling folgt das Groups-Element. Es schachtet eine Sequenz von Gruppen. Eine Gruppe (Group) hostet eine beliebige Anzahl an Controls. Über das Template-Attribut wird die Vorlage zur Darstellung der Elemente einer Gruppe referenziert. SharePoint liefert hierbei die Möglichkeit, ein Standard-Template zu verwenden (z. B. Ribbon.Templates.Flexible2 ) oder eine benutzerdefinierte Vorlage (GroupTemplate) zu spezifizieren. Das Flexible-Template kann in der CMDUI.CML nachgelesen werden. Weiterhin wird innerhalb des Group-Elements die Position über das Sequence-Attribut festgelegt. Anders als bei Tabs werden die Standardsequenzen in 10er-Schritten aufgebaut. Sollte die Gruppe in ein Standard-Tab integriert werden, sollte die Sequenz nicht durch 10 teilbar sein; bei benutzerdefinierten Gruppen kann die Sequenz frei gewählt wählen.

Innerhalb einer Gruppe kann eine beliebige Anzahl von Controls platziert werden. Das Ribbon Framework ermöglicht die Bereitstellung von Buttons, Checkboxen, Comboboxen, Drop Down-Feldern oder Textboxen. Eine Liste der von SharePoint unterstützen Controls liefert das SDK. Je nach Typ können dem Element unterschiedliche Eigenschaften mitgegeben werden. Bei Buttons beispielsweise das Icon, der Event Handler für das Command oder der Label-Text. Auch hier muss eine Sequenznummer angegeben werden. Über das TemplateAlias-Attribut wird ein Bereich des GroupTemplates zugeordnet. Hier besteht die Möglichkeit ein Standardalias (z. B. o1) oder den eines benutzerdefinierten Templates zu referenzieren.

   1: <CommandUIDefinition Location="Ribbon.Templates._children">

   2:           <GroupTemplate Id="Ribbon.Templates.Large">

   3:             <Layout Title="TwoLarge" LayoutTitle="TwoLarge">

   4:               <Section Alignment="Top" Type="OneRow">

   5:                 <Row>

   6:                   <ControlRef DisplayMode="Large" TemplateAlias="c1" />

   7:                 </Row>

   8:               </Section>

   9:               <Section Alignment="Top" Type="OneRow">

  10:                 <Row>

  11:                   <ControlRef DisplayMode="Large" TemplateAlias="c2" />

  12:                 </Row>

  13:               </Section>

  14:             </Layout>

  15:           </GroupTemplate>

  16:         </CommandUIDefinition>

17:

Über das GroupTemplate wird das HTML-Gerüst mittels Sektionen (Section) und Zeilen (Row) definiert. Pro Sektion werden die Ausrichtung (Top, Middle) und der Typ (Devider, OneRow, TwoRow, ThreeRow) definiert. Auf Ebene einer Zeile werden die Darstellungsart (z. B. Medium, Large, Text) sowie der Alias (TemplateAlias) definiert.

   1: <CommandUIHandlers>

   2:         <CommandUIHandler

   3:           Command="CustomMessage"

   4:           CommandAction="javascript: javascript:alert('Hello from the ribbon');" />

   5:       </CommandUIHandlers>

Über das CommandUIHandlers-Element werden die Event Handler für die Buttons deklariert. Über das CommandAcition-Attribut kann das JavaScript hinterlegt werden, das beim jeweiligen Kommando ausgeführt werden soll. Hier besteht die Möglichkeit, einen kompletten Scriptblock oder die Referenz einer externen Methode zu hinterlegen.

Das Ribbon Customizing erinnert mich ein wenig an die Anfangszeit der Entwicklung von Office 2007-Ribbons. Bei so vielen manuellen Schritten bleibt nur zu hoffen, dass Microsoft oder die Community demnächst ein Ribbon Designer herausbringt.

Service Accounts und deaktivierte Benutzer aus dem Profilimport ausschließen

Fabian Moritz — Thu, 06 May 2010 08:15:00 GMT

Der SharePoint 2007-Profilimport gibt leider nur bedingt die Möglichkeit eines granularen Imports anhand dedizierter OUs (man kann pro Connection nur eine OU auswählen). Aus diesem Grund wird in einigen Umgebungen das komplette AD indiziert. Sollten in dieser Konstellation aber dennoch bestimmte Accounts entfernt werden, gibt es bei dem Profilimport die Möglichkeit, einen LDAP-Filter zu definieren. Der folgende LDAP-Filter entfernt sämtliche Accounts, die deaktiviert sind, sowie Benutzerkonten, bei denen der Wert homeDirectory nicht gesetzt ist (über den Weg der LDAP Wildcard-Suche).

(&(objectCategory=person)(objectClass=user)(!(userAccountControl:1.2.840.113556.1.4.803:=2))(homeDirectory=*))

Sollten Service Accounts oder andere Benutzerprofile anhand eines AD-Attributs identifiziert werden können, lassen sie sich über diesen Weg aus dem Profilimport ausschließen. Das UserAccountControl Flag deklariert den Zustand des Accounts; eine Anleitung, deaktivierte Konten vom Import auszuschließen, liefert KB827754.

In SharePoint 2010 wird dieser Filter nicht mehr zwingend erforderlich sein, da der Profilimport aus dem AD die Auswahl mehrerer OUs erlaubt!

Fehler beim Start des SharePoint 2010 User Profile Synchronization Services

Fabian Moritz — Wed, 05 May 2010 14:39:48 GMT

Der Profilimport bei SharePoint 2010 ist in seiner Initialkonfiguration sehr störrisch. Sollte der Server nach Best Practices installiert worden sein, gibt es keine Möglichkeit, den User Profile Sychronization Service zu starten. Dieser Versuch resultiert in folgendem Fehler in der Ereignisdatenbank:

The Execute method of job definition Microsoft.Office.Server.Administration.ProfileSynchronizationSetupJob (ID XXX) threw an exception… An update conflict has occurred, and you must re-try this action. The object UserProfileApplication Name=User Profile Service Application was updated by <CA Account>, in the OWSTimer (ID) process, on machine <Machine Name>…

Nach ein wenig Recherche bin ich auf einen Artikel gestoßen, der beschreibt, welche Voraussetzungen es gibt, den Profiledienst starten zu können:

The Server Farm account, which is created during the SharePoint farm setup, must also be a member of the Administrators group on the server where the User Profile Synchronization service is deployed. For more information, see Account permissions and security settings (SharePoint Server 2010).

Quelle: http://technet.microsoft.com/en-us/library/ee721049(office.14).aspx

Hm, auch wenn ich es nicht richtig glauben möchte, es ist tatsächlich erforderlich diesen Service Account in die Gruppe der lokalen Administratoren hinzuzufügen. Danach kann der Dienst gestartet und der Profilimport konfiguriert werden.

Ich fühle mich ein wenig an die Anfangszeit von MOSS erinnert und hoffe, dass diese Voraussetzung mit einem der ersten Patches aus der SharePoint-Architektur verschwindet!

FileNotFoundException-Fehler bei einer SharePoint 2010-Konsolenanwendung

Fabian Moritz — Wed, 05 May 2010 12:11:06 GMT

Sollte jemand eine Konsolenanwendung in Visual Studio 2010 für SharePoint 2010 entwickeln, kann es passieren, dass ihn folgende Fehlermeldung begrüßt: The Web application at <URL der Site Collection> could not be found. Die Ursache dieses Fehlers liegt darin, dass die Zielplattform nicht auf Any CPU gesetzt ist. Diese Einstellung kann in Visual Studio 2010 in den Projekteigeschaften geändert werden.

Cannot start service SPUserCodeV4 bei neuen Sandbox Solutions

Fabian Moritz — Tue, 04 May 2010 12:08:30 GMT

Auf einem frisch installierten SharePoint Server 2010 wird den einen oder anderen eventuell diese Fehlermeldung beim Deployment-Versuch einer Sandbox Solution begrüßen.

Der Fehler hängt damit zusammen, dass die der Dienst zur Ausführung von Sandbox Solutions nicht gestartet ist. Der Service kann über folgenden Weg gestartet werden: Administration > Application Management > Manage services on server

Dass dieser Dienst standardmäßig nicht gestartet ist, betrachte ich als durchaus verständlich, weil mit der Nutzung der Sandbox Solutions einige Vorüberlegungen und Konfigurationsschritte einhergehen.

SharePoint 2010 Client Objektmodell – Erweiterte Anwendungsbeispiele

Fabian Moritz — Mon, 03 May 2010 18:07:57 GMT

Im letzten Teil dieser Serie werde ich anhand erweiterter Anwendungsbeispiele zeigen, für welche Zwecke das Client-Objektmodell auch genutzt werden kann. Von der Erstellung und Verwaltung von Listenelementen, Dokumenten oder Webseiten bis hin zur Berechtigung von Benutzern – das Client-Objektmodell liefert sehr vielseitige Einsatzmöglichkeiten.

Listenelemente erstellen
Das SharePoint 2010 Client-Objektmodell liefert, neben dem auslesen von Listenelementen, auch die Möglichkeit der Manipulation von Daten. Das nachfolgende Beispiel veranschaulicht, wie mittels der AddItem-Methode eines List-Objekts neue Elemente einer Liste hinzugefügt werden können.

   1: using System;

   2: using Microsoft.SharePoint.Client;

3:

   4: class Program

   5: {

   6:    static void Main(string[] args)

   7:    {

   8:       ClientContext clientContext = new ClientContext("http://win7-fm-t400");

   9:       Web web = clientContext.Web;

  10:       List listCustomers = web.Lists.GetByTitle("Customers");

11:

  12:       // Create new customer item

  13:       ListItemCreationInformation customerItemCreateInfo =

  14:          new ListItemCreationInformation();

  15:       ListItem customerItem = listCustomers.AddItem(customerItemCreateInfo);

  16:       customerItem["Title"] = "Schilling4";

  17:       customerItem["FirstName"] = "Marga";

  18:       customerItem["Company"] = "Contoso GmbH";

  19:       customerItem.Update();

20:

  21:       clientContext.ExecuteQuery();

22:

  23:       Console.WriteLine("New customer created successfully: {0}, {1}",

  24:          customerItem.Id,

  25:          customerItem["Title"].ToString());

26:

  27:       // Add a new order

  28:       List listOrders = web.Lists.GetByTitle("Orders");

29:

  30:       ListItemCreationInformation ordersItemCreateInfo =

  31:          new ListItemCreationInformation();

  32:       ListItem orderItem = listOrders.AddItem(ordersItemCreateInfo);

  33:       orderItem["Title"] = Guid.NewGuid().ToString();

  34:       orderItem["Article"] = "Bike Mobo";

  35:       orderItem["Amount"] = 3.0;

  36:       orderItem["Customer"] = new FieldLookupValue()

  37:       {

  38:          LookupId = customerItem.Id

  39:       };

40:

  41:       orderItem.Update();

42:

  43:       clientContext.ExecuteQuery();

44:

  45:       Console.WriteLine("New order created successfully: {0}, {1}",

  46:          orderItem.Id,

  47:          orderItem["Title"].ToString());

  48:    }

  49: }

Eine wichtige Rolle übernimmt die ListItemCreationInformation-Klasse mit deren Hilfe die einzelnen Attribute des neuen Elements spezifiziert werden können. Die Add-Methode erwartet als Parameter ein Objekt dieses Typs zur Spezifizierung der jeweiligen Informationen des neuen SharePoint-Elements. Der zweite Teil dieses Codebeispiels zeigt, wie mit Unterstützung der FieldLookupValue-Klasse Nachschlagespalten einem Listenelement zugewiesen werden können. Die ID des neuen Elements steht nach Ausführung von ExecuteQuery zur Weiterverarbeitung zur Verfügung.

Listenelemente manipulieren
Das editieren und löschen von bestehenden Elementen ist vergleichsweise einfach. Das erste Beispiel demonstriert die Manipulation eines Listenelements, wohingegen das nachfolgende Listing zeigt, wie bestehende Elemente, unter Verwendung der DepleteObjekt-Methode, gelöscht werden können.

   1: using System;

   2: using Microsoft.SharePoint.Client;

3:

   4: class Program

   5: {

   6:    static void Main(string[] args)

   7:    {

   8:       ClientContext clientContext = new ClientContext("http://win7-fm-t400");

9:

  10:       Web web = clientContext.Web;

  11:       List list = web.Lists.GetByTitle("Orders");

12:

  13:       ListItemCollection allItems = list.GetItems(new CamlQuery()

  14:       {

  15:          ViewXml = @" <View>

  16:                            <Query>

  17:                               <Where>

  18:                                  <Geq>

  19:                                     <FieldRef Name='ID'/>

  20:                                     <Value Type='Integer'>9</Value>

  21:                                  </Geq>

  22:                               </Where>

  23:                            </Query>

  24:                            <RowLimit>100</RowLimit>

  25:                         </View>"

  26:       });

27:

  28:       clientContext.Load(allItems,

  29:          items => items.IncludeWithDefaultProperties(

  30:             i => i["Title"],

  31:             i => i["Amount"])

  32:             );

33:

  34:       clientContext.ExecuteQuery();

35:

  36:       if (allItems != null && allItems.Count > 0)

  37:       {

  38:          ListItem item = allItems[0];

  39:          item["Amount"] = 5.0;

  40:          item.Update();

41:

  42:          clientContext.ExecuteQuery();

  43:          Console.WriteLine("Order updated successfully: {0}, {1}",

  44:             item.Id,

  45:             item["Title"].ToString());

  46:        }

  47:    }

  48: }

   1: using System;

   2: using Microsoft.SharePoint.Client;

3:

   4: class Program

   5: {

   6:    static void Main(string[] args)

   7:    {

   8:       ClientContext clientContext = new ClientContext("http://win7-fm-t400");

9:

  10:       Web web = clientContext.Web;

  11:       List list = web.Lists.GetByTitle("Orders");

12:

  13:       ListItemCollection allItems = list.GetItems(new CamlQuery()

  14:       {

  15:          ViewXml = @" <View>

  16:                            <Query>

  17:                               <Where>

  18:                                  <Geq>

  19:                                     <FieldRef Name='ID'/>

  20:                                     <Value Type='Integer'>9</Value>

  21:                                  </Geq>

  22:                               </Where>

  23:                            </Query>

  24:                            <RowLimit>100</RowLimit>

  25:                         </View>"

  26:       });

27:

  28:       clientContext.Load(allItems,

  29:          items => items.IncludeWithDefaultProperties(

  30:             i => i["Title"],

  31:             i => i["Amount"])

  32:             );

33:

  34:       clientContext.ExecuteQuery();

35:

  36:       if (allItems != null && allItems.Count > 0)

  37:       {

  38:          ListItem item = allItems[0];

  39:          item.DeleteObject();

40:

  41:          clientContext.ExecuteQuery();

42:

  43:          Console.WriteLine("Order deleted successfully: {0}, {1}",

  44:             item.Id,

  45:             item["Title"].ToString());

  46:       }

  47:    }

  48: }

Dokumente hochladen
Der Dokumentenupload kommt mit verhältnismäßig wenig Programmcode aus.

   1: using System;

   2: using Microsoft.SharePoint.Client;

   3: using System.IO;

4:

   5: class Program

   6: {

   7:    static void Main(string[] args)

   8:    {

   9:       ClientContext clientContext =

  10:          new ClientContext("http://win7-fm-t400");

11:

  12:       using (FileStream stream = new FileStream(@"C:\temp.txt",FileMode.Open))

  13:       {

  14:          Microsoft.SharePoint.Client.File.SaveBinaryDirect(

  15:             clientContext,

  16:             "/Shared Documents/temp.txt",

  17:             stream,

  18:             true);

  19:       }

  20:    }

  21: }

Mittels der Methode Microsoft.SharePoint.Client.File.SaveBinaryDirect können Dokumente in ein beliebiges Verzeichnis einer SharePoint Site hochgeladen werden. Im Unterschied zu den bisher vorgestellten Beispielen kommt diese Methode ohne die Ausführung von ExecuteQuery aus und lädt stattdessen direkt das Dokument in seinen vorgesehenen Bereich. Als Parameter erwartet die Methode mindestens den Pfad, des Binary Stream sowie den ClientContext. Wer Dokumente herunterladen möchte, kann die Methode Microsoft.SharePoint.Client.File.OpenBinaryDirect zu Hilfe nehmen.

Webseiten erstellen
Die Erstellung von Webs innerhalb einer Site Collection ist genauso einfach wie die Erzeugung neuer Listenelemente.

   1: using System;

   2: using Microsoft.SharePoint.Client;

   3: using System.Net;

4:

   5: class Program

   6: {

   7:    static void Main(string[] args)

   8:    {

   9:       ClientContext clientContext =

  10:          new ClientContext("http://win7-fm-t400");

  11:       Web web = clientContext.Web;

12:

  13:       Web newWeb = web.Webs.Add(new WebCreationInformation()

  14:       {

  15:          Title = "Neue Unterwebseite",

  16:          Url = "Subsite",

  17:          UseSamePermissionsAsParentSite = true,

  18:          Language = 1033,

  19:          WebTemplate = "STS#0"

  20:       });

21:

  22:       clientContext.Load(

  23:           newWeb,

  24:           w => w.ServerRelativeUrl,

  25:           w => w.Created);

26:

  27:       clientContext.ExecuteQuery();

28:

  29:       Console.WriteLine("Neue Website erfolgreich erstellt: {0} ({1})",

  30:          newWeb.ServerRelativeUrl,

  31:          newWeb.Created);

  32:    }

  33: }

Unter Zuhilfenahme der WebCreationInformation-Klasse können die Information der neu zu generierenden Webseite spezifiziert werden. Zu diesen Eigenschaften gehören zum Beispiel der Titel, die Beschreibung, die zu verwendende Webseitvorlage, oder die Sprache. Die Add-Methode des Web-Objekts ermöglicht die Erstellung einer neuen Unterwebseite. Mittels der Load-Methode werden in diesem Beispiel zusätzliche Eigenschaftes des Webs zur späteren Ausgabe eingeladen.

Gruppen und Benutzerdaten auslesen
Im letzten Teil dieses Artikels werde ich beschreiben, wie über den Weg des Client-Objektmodells Benutzerinformationen ausgelesen oder Benutzer berechtigt werden können. Das erste Beispiel demonstriert, wie Gruppen- und Benutzerinformationen einer SharePoint Site ausgelesen werden können.

   1: using System;

   2: using Microsoft.SharePoint.Client;

3:

   4: class Program

   5: {

   6:    static void Main(string[] args)

   7:    {

   8:       ClientContext clientContext =

   9:          new ClientContext("http://win7-fm-t400");

10:

  11:       GroupCollection siteGroups = clientContext.Web.SiteGroups;

12:

  13:       clientContext.Load(siteGroups,

  14:          group => group.Include(

  15:             g => g.Title,

  16:             g => g.Users.Include(

  17:                u => u.Title,

  18:                u => u.Email,

  19:                u => u.LoginName)));

20:

  21:       clientContext.ExecuteQuery();

22:

  23:       Group groupMembers = null;

24:

  25:       foreach (Group g in siteGroups)

  26:       {

  27:          Console.WriteLine("{0} ({1} member)", g.Title, g.Users.Count);

28:

  29:          foreach (User u in g.Users)

  30:          {

  31:             Console.WriteLine(" > {0} ({1})", u.Title, u.Email);

  32:          }

  33:       }

  34:    }

  35: }

Unter Zuhilfenahme der Group und User-Klasse werden in diesem Codeblock zunächst die Gruppen und dann die darin enthaltenen Benutzer iteriert. Die Filterung der zu landenden Eigenschaften wird analog dem Einlesen von Listenelemente mittels der Load-Methode und speziellen Lambda-Ausdrücken realisiert.

Neue Benutzer über den Weg der UserCollection.Add-Methode einer SharePoint-Gruppe hinzugefügt werden.

   1: using System;

   2: using Microsoft.SharePoint.Client;

3:

   4: class Program

   5: {

   6:    static void Main(string[] args)

   7:    {

   8:       ClientContext clientContext =

   9:          new ClientContext("http://win7-fm-t400");

10:

  11:       GroupCollection siteGroups = clientContext.Web.SiteGroups;

12:

  13:       clientContext.Load(siteGroups);

14:

  15:       clientContext.ExecuteQuery();

16:

  17:       Group groupMembers = null;

18:

  19:       foreach (Group g in siteGroups)

  20:       {

  21:          if (g.Title.Contains("Members"))

  22:             groupMembers = g;

  23:       }

24:

  25:       // Adding user to Contributors

  26:       UserCreationInformation uci = new UserCreationInformation();

  27:       uci.Title = "Marga Schilling";

  28:       uci.LoginName = "itacs\\cku";

  29:       uci.Email = "cku@itacs.de";

30:

  31:       User newUser = groupMembers.Users.Add(uci);

32:

  33:       clientContext.ExecuteQuery();

  34:    }

  35: }

Sie erwartet als Parameter ein Objekt vom Typ UserCreationInformationen und erzeugt ein Rückgabewert vom Typ User. Die UserCreationInformationen-Klasse wird dann genutzt, wenn ein neuer Benutzer einer SharePoint-Gruppe hinzugefügt wird. Sollte der User bereits existieren kann alternativ auch die AddUser-Methode verwendet werden.

Das war vorerst mein letzter Beitrag zum SharePoint 2010 Client-Objektmodell. Wie geht’s jetzt weiter? Ende Mai wird auf microsoft.com ein Webcast zu diesem Thema zu finden sein. Ich werde mich auf jeden Fall weiter mit dem Client-Objektmodell befassen; sollte hierzu etwas Neues zu Berichten sein, werde ich es an dieser Stelle veröffentlichen.

Veranstaltungstipp: ShareConnect 2010

Fabian Moritz — Mon, 03 May 2010 07:15:38 GMT

Auch in diesem Jahr öffnet die ShareConnect wieder Ihre Pforten und lädt vom 20. bis 23. September in die Rheingoldhalle in Mainz ein. Die noch sehr junge Veranstaltung wird parallel zur Basta stattfinden. Ein Großteil der Sessions steht bereits fest und wurde am Wochenende auf der offiziellen Webseite veröffentlicht. Ich bin in diesem Jahr wieder im Advisory Board und kann versprechen, dass die Themen eine hohe Qualität aufweisen. Die in die Bereiche Administration, Management, Development und Business Solutions klassifizierten Sessions befassen sich ausschließlich mit SharePoint 2010 und liefern damit sowohl für Entwickler als auch für IT Pros und Entscheider ein reichhaltiges Programm. Auch ich werde inhaltlich meinen Teil zur Veranstaltung beitragen und eine Session zur Suche sowie zum Thema Web Content Management übernehmen.

SharePoint 2010 Lizenzierung – Teil 1 (Übersicht)

Fabian Moritz — Fri, 23 Apr 2010 15:49:20 GMT

Nachdem ich mich in SharePoint 2007 ausführlich mit dem Thema Lizenzierung beschäftigt hatte, möchte ich auch zum neulich veröffentlichten SharePoint Server 2010 eine Artikelserie folgen lassen. Im ersten Teil werde ich eine Übersicht der Server-Produktversionen sowie der möglichen Lizenzierungsvarianten geben.

Der Funktionsumfang von SharePoint 2010

Bevor ich mich auf die unterschiedlichen Produkt- und Lizenzierungsvarianten stürze, möchte ich den technologischen Funktionsumfang von SharePoint 2010 vorstellen – dem einen oder anderen auch als „SharePoint Glücksrad“ oder „SharePoint Bagel“ bekannt. SharePoint 2010 definiert sechs komplett neue Themenblöcke, die ich bewusst nicht übersetzen möchte.

Sites
SharePoint Sites liefert eine einheitliche Infrastruktur zur Bereitstellen von Webseiten für Intranet- Extranet- oder Internetszenarien. SharePoint Sites präsentieren sich in einem komplett überarbeiteten Outfit inkl. einer durchgängigen Ribbon UI, Dialogfunktionen oder AJAX Support. Hinzu kommen neue Funktionen für die Arbeit mit mobilen Geräten, dem SharePoint Workspace sowie die verbesserte Integration in Office.

Communities
SharePoint 2010 ermöglicht seinen Anwendern eine effiziente Zusammenarbeit über unterschiedliche Wege. Sie können in individuellen Gruppen zusammenarbeiten, Informationen klassifizieren oder bewerten, Kollegen anhand von Fähigkeiten suchen oder sich mit anderen Anwendern verbinden. SharePoint liefert hierzu neue Funktionen, wie zum Beispiel Tagging (und Tag Clouds), Rating oder Social Bookmarking, Verbesserungen in Blogs, Wikis sowie in den My Site Features.

Content
Die Bereitstellung, Verwaltung und Kontrolle von unterschiedlichen Inhalten spielt für SharePoint eine sehr wesentliche Rolle. SharePoint 2010 unterstützt den gesamten Lebenszyklus des Content Managements und liefert hierfür zum Beispiel Funktionen, wie Enterprise Content Types, Document Sets, neu Metadatenfunktionalitäten, einen externen Blob Storage sowie Support für Audio und Video.

Search
Die neue SharePoint-Generation ermöglicht die Suche von unterschiedlichen Webinhalten, Dokumenten, Personen oder Daten aus externen Systemen. SharePoint 2010 liefert hierfür neue Relevanz-Funktionen, eine phonetische Suche, Suchfacetten sowie eine FAST-Integration.

Insights
SharePoint 2010 befähigt seine Anwender mit Daten aus strukturierten und unstrukturierten Datenquellen zu interagieren. In diesen Technologieblock sind Funktionen, wie PerformancePoint Services, Excel Services, Chart Webparts, Visio Services, Web Analytics oder PowerPivot anzutreffen.

Composites
Die Plattform von SharePoint 2010 ermöglicht die Umsetzung von Non Code und programmierten Lösungen auf eine flexible Art und Weise. Zur Unterstützung dieser Prozesse stellt SharePoint 2010 einen komplett überarbeiteten SharePoint Designer, InfoPath Forms Services, Business Connectivity Services, neue Workflow-Funktionen sowie ein deutlich verbessertes Visual Studio bereit.

Welche Produktversionen gibt es?

Bei den Produktversionen von SharePoint 2010 hat sich nicht nur die Produktbezeichnung (das „Windows“ und „Office“ entfällt) geändert, es sind auch neue Produkt- und Lizenzierungsvarianten hinzugekommen. Hier eine Übersicht der SharePoint Produkt- und Lizenzierungstypen:

Die von mir genutzten Abkürzungen der Produktversionen sind teilweise frei erfunden; sollte jemand eine Quelle für die korrekten Bezeichnungen kennen, würde ich mich über eine kurze Info freuen!

Microsoft SharePoint Foundation 2010 (SPF)
SPF ist der Nachfolger der Windows SharePoint Services 3.0 und stellt die Basisdienste der SharePoint-Technologie bereit. Hierbei beschränkt sich die neue Version, im Unterschied zu seinem Vorgänger, nicht nur allein auf die Zusammenarbeitsfunktionen, sondern stellt zusätzlich Features für Content, Communities oder die Suche bereit. SharePoint Foundation 2010 wird über die Windows CAL lizenziert und ist damit quasi kostenlos.

Microsoft SharePoint Server 2010 Standard (SPS-S)
Der SharePoint Server 2010 ist ein vollständig zu lizenzierendes Client/Server-Produkt. Neben der Serverlizenz muss jeder Clientzugriff durch eine entsprechende Clientzugriffslizenz (CAL) lizenziert werden. Im Vergleich zur Enterprise-Version fehlen der Standard-CAL Features bei der Suche (kein FAST Support), Composites (InfoPath Forms Service, BCS Webparts oder Access Service) sowie der komplette Funktionsumfang des Insights-Blocks. Wie auch bei anderen Microsoft-Produkten kann der Clientzugriff pro Benutzer oder Computer lizenziert werden.

Microsoft SharePoint Server 2010 Enterprise (SPS-E)
Die Enterpriese Client-Zugriffslizenz ermöglicht die Nutzung des kompletten Funktionsumfangs von SharePoint Server 2010. Die Lizenz muss zusätzlich zur Standard CAL bezogen werden. Analog der Vorversion können Standard und Enterprise CALs gemischt werden; nur für Anwender, die Enterprise-Funktionen nutzen, muss diese erweiterte CAL erworben werden. Sowohl bei der Standard- als auch bei der Enterprise CAL muss zusätzlich noch eine Serverlizenz pro Frontend bzw. Anwendungsserver erworben werden.

Microsoft SharePoint Server 2010 for Internet Sites Standard (SPSFIS-S)
Diese Lizenzierungsvariante wurde mit SharePoint Server 2010 neu eingeführt. Sie ermöglicht die Nutzung der SharePoint Standard Features in Extranet- oder anonymen Internetszenarien und dient hiermit kleinen und mittleren Umgebungen. SPSFIS-S ist eine Server-Lizenzvariante und muss pro Server einer SharePoint-Farm erworben werden. Für SharePoint Server 2010 for Internet Sites gibt es keine CALs.

Microsoft SharePoint Server 2010 for Internet Sites Enterpriese (SPSFIS-E)
Diese Produktversion ist identisch der des Vorgängers. SPSFIS Enterprise ermöglicht die Nutzung des vollen SharePoint-Funktionsumfangs in Extranet- oder Internetwebseiten. Die Art der Lizenzierung ist identisch der Standardversion.

Microsoft Search Server 2010 (MSS)
Diese Produktversion stellt die Suchfunktionen des SharePoint Severs 2010 bereit. Im Unterschied zum SharePoint Server fehlen dem Search Server die Personensuche, Taxonomie Support sowie Social Search-Funktionalitäten. Der Search Server wird auf Basis einer Client/Server-Modells lizenziert.

Microsoft Search Server 2010 Express (MSSEX)
Diese Produktversion stellt denselben Funktionsumfang wie sein lizenzpflichtiges Pendant bereit, mit dem Unterschied, dass mit der Express-Version nur Single Server-Installationen möglich sind. Der Search Server Express wird identisch SPF über die Windows CAL lizenziert.

Microsoft FAST Search Server 2010 for SharePoint (FS4SP)
Die von Microsoft aufgekaufte FAST-Suchtechnologie wurde mit FAST Search Server for SharePoint in die SharePoint-Technologie überführt. Der Kern der FAST-Suche kommt nach wie vor von FAST, wohingegen das Querying und die Administration nach SharePoint überführt wurden. FAST nutzt die SharePoint Frontend Server als Query Server sowie zum Crawling von Inhalten. Zusätzlich fügt FAST weitere Server der SharePoint-Farm hinzu, um den gecrawlten Inhalt abzuarbeiten, die Indexpartitionen aufzubauen oder Suchanfragen zu beantworten. Für eine SharePoint-Umgebung sind mindestens zwei zusätzliche FAST Server (Query und Index) erforderlich. Diese Server sind pro Instanz separat zu lizenzieren. Zusätzlich ist für die Nutzung der FAST-Suche eine SharePoint Enterprise CAL erforderlich. Beachtet werden sollte, dass eine FAST Farm für mehrere SharePoint-Farmen bereitgestellt werden kann. Im Unterschied zur SharePoint-Suche liefert FAST unter anderem erweiterte Funktionen, wie visuelle beste Suchergebnisse, Document Previews und Thumbnails, ähnliche Resultate, eine erweiterte Sortierung, Suchverfeinerungen sowie Support zur Indizierung von erweiterten Webinhalten inkl. JavaScript.

Microsoft FAST Search Server 2010 for SharePoint Internet Sites (FSIS)
Diese Produktversion ist vom Funktionsumfang vergleichbar mit der von FAST Search Server 2010 for SharePoint. Sie wird separat pro Server lizenziert. Zusätzlich ist für die Nutzung von FSIS die Lizenzierung von Microsoft SharePoint Server 2010 for Internet Sites Enterprise erforderlich.

Microsoft FAST Search Server for Internet Applications (FSIA)
Bei dieser Produktversion hat eigentlich nur der Name noch etwas mit SharePoint zu tun. Im Kern verbirgt sich hinter FAST Search Server for Internet Applications die klassische FAST ESP-Suche. Sie basiert auf einer Client/Server-Lizenzmodell. Die CAL hat, im Unterschied zu FS4SP, nichts mit der Enterprise CAL zu tun und muss separat lizenziert werden. Zusätzlich muss bei FSIA eine Lizenz für jede Serverinstanz bezogen werden.

Im nächsten Artikel werde ich etwas zu den Preisen sowie zu den möglichen Erwerbsformen schreiben; da SharePoint 2010 noch sehr frisch in den Regalen steht, kann es mit dem zweiten Teil noch ein bisschen dauern.

Veranstaltungstipp: Microsoft SharePoint Konferenz 2010 in Wien

Fabian Moritz — Wed, 21 Apr 2010 08:10:18 GMT

Vom 9. bis 10. Juni findet in Wien die österreichische Microsoft SharePoint Konferenz statt. Erstmals nach der großen SharePoint Konferenz 2007 in Frankfurt gibt es damit wieder eine offizielle Veranstaltung von Microsoft. Der Veranstalter preist das Event als die größte SharePoint Konferenz in Österreich. Ich selbst werde auch vor Ort sein und zwei Sessions zu Office Development und Web Content Management halten. Zu einem Preis von 549,00 Euro ist die Veranstaltung sehr erschwinglich und bestimmt eine Reise wert! Weitere Infos gibt es auf der offiziellen Webseite.

SharePoint 2010 Client-Objektmodell – Datenabfragen

Fabian Moritz — Wed, 21 Apr 2010 06:31:51 GMT

Nachdem ich im ersten Artikel dieser Serie das Client-Objektmodell eingeführt habe, möchte ich im heutigen Posting anhand von einigen Anwendungsbeispielen zeigen, wie diese Technologie zur effizienten Abfrage von Daten angewandt werden kann. Von einer einfachen Datenabfrage bis hin zur Verwendung von LINQ oder CAML – das Client-Objektmodell liefert für diese Anwendungsfälle reichhaltige Optionen.

Einfache Datenabfragen
Das Client-Objektmodell stellt für die Abfrage von Daten aus einer SharePoint-Umgebung unterschiedliche Möglichkeiten bereit. Die einfachste Variante ist die Verwendung der Load-Methode. Sie liefert die Möglichkeit, beliebige Informationen einer SharePoint-Umgebung in ein Client-Objekt zu laden. Im einfachsten Fall wird der Methode das gewünschte Objekt als Parameter mitgegeben.

   1: using System;

   2: using Microsoft.SharePoint.Client;

3:

   4: class Program

   5: {

   6:    static void Main(string[] args)

   7:    {

   8:       ClientContext clientContext = new ClientContext("http://win7-fm-t400");

   9:       Web web = clientContext.Web;

  10:       List list = web.Lists.GetByTitle("Customers");

11:

  12:       clientContext.Load(list);

  13:       clientContext.ExecuteQuery();

14:

  15:       Console.WriteLine("{0} ({1})", list.Title, list.ItemCount);

  16:    }

  17: }

Die Ausführung der ExecuteQuery-Methode führt dazu, dass die Abfrage an den Server gesendet und ausgeführt wird. Dieses Vorgehen beschreibt eines der wesentlichsten Unterschiede zum serverseitigen Objektmodell, bei dem die Informationen mit dem Zugriff auf die Objekte direkt aus der Datenbank geladen werden. Über die ExecuteQuery-Methode liefert das Client-Objektmodell die Möglichkeit, mehrere Abfragen in einem Server Roundtrip zu bündeln.

Datenabfragen einschränken
Besonders bei der Verarbeitung von großen Datenmengen ist es ratsam, den Datenverkehr auf ein Minimum zu reduzieren. Das Client Objektmodell liefert die Option, mittels eines Lambda-Ausdrucks die von einer Anfrage zurückgegebenen Objekte einzugrenzen. Hierdurch werden nur die im Ausdruck definierten Eigenschaften vom JSON-Paket zurückgegeben. Das nachfolgende Beispiel demonstriert die Anwendung dieses Verfahren.

   1: using System;

   2: using Microsoft.SharePoint.Client;

3:

   4: class Program

   5: {

   6:    static void Main(string[] args)

   7:    {

   8:       ClientContext clientContext = new ClientContext("http://win7-fm-t400");

9:

  10:       Web web = clientContext.Web;

  11:       List list = web.Lists.GetByTitle("Customers");

12:

  13:       clientContext.Load(list,

  14:          l => l.Title,

  15:          l => l.ItemCount);

16:

  17:       clientContext.ExecuteQuery();

18:

  19:       Console.WriteLine("{0} ({1})", list.Title, list.ItemCount);

  20:    }

  21: }

Der Load-Methode wird ein Lambda-Ausdruck als Parameter übergeben, der die von der Abfrage zurückgegebenen Spalten vorgibt. In diesem Fall werden von der abgefragten Liste ausschließlich der Titel sowie die Anzahl der Elemente zurückgegeben. Sollte der Programmcode auf eine nicht definierte Eigenschaft zugreifen, wird eine Ausnahme vom Typ PropertyOrFieldNotInitializedException geworfen. Besonders bei der Verarbeitung von großen Datenmengen wird sich dieses Verfahren auf die Performance des Programmcodes spürbar auswirken.

Schauen wir uns zum Beweis dieser Aussage zunächst einmal das vom Server zurückgegebene JSON-Paket ohne Einschränkung an:

"_ObjectType_":"SP.List","_ObjectIdentity_":"740c6a0b-85e2-48a0-a494-e0f1759d4aa7:web:8b8b379a-90f7-42f6-9f72-6e9fca3d434f:list:cf9bef19-1480-45c4-a2b7-ab8a08ea1dd2","_ObjectVersion_":"2","ParentWebUrl":"\u002f","HasExternalDataSource":false,"Created":"\/Date(1259488496000)\/","LastItemModifiedDate":"\/Date(1266682195000)\/","LastItemDeletedDate":"\/Date(1259488496000)\/","Id":"\/Guid(cf9bef19-1480-45c4-a2b7-ab8a08ea1dd2)\/","Description":"","Title":"Customers","Direction":"none","BaseType":0,"ImageUrl":"\u002f_layouts\u002fimages\u002fitcontct.png","ItemCount":2,"BaseTemplate":105,"DefaultContentApprovalWorkflowId":"\/Guid(00000000-0000-0000-0000-000000000000)\/","TemplateFeatureId":"\/Guid(00bfea71-7e6d-4186-9ba8-c047ac750105)\/","DefaultViewUrl":"\u002fLists\u002fCustomer\u002fAllItems.aspx","DefaultEditFormUrl":"\u002fLists\u002fCustomer\u002fEditForm.aspx","DefaultNewFormUrl":"\u002fLists\u002fCustomer\u002fNewForm.aspx","DefaultDisplayFormUrl":"\u002fLists\u002fCustomer\u002fDispForm.aspx","EnableAttachments":true,"ServerTemplateCanCreateFolders":true,"EnableFolderCreation":false,"EnableModeration":false,"EnableVersioning":false,"ForceCheckout":false,"EnableMinorVersions":false,"DraftVersionVisibility":0,"Hidden":false,"IsApplicationList":false,"IsCatalog":false,"AllowContentTypes":true,"DocumentTemplateUrl":null,"ContentTypesEnabled":false,"MultipleDataList":false,"NoCrawl":false

Mit der Einschränkung wird vom Server folgendes abgespecktes Paket zurückgeliefert.

Dieser Vergleich veranschaulicht sehr deutlich die Unterschiede der beiden Abfragevarianten. Aus diesem Grund würde ich stets anraten, die eingeschränkte Abfrageform zu verwenden.

Verschachtelte Abfragen
Neben der einfachen Filterung können die Eigenschaftseinschränkungen auch auf mehreren Ebenen abgebildet werden. Mittels der erweiterten Include-Methode können die zu ladenden Eigenschaften für jedes einzelne Element einer Collection spezifiziert werden. Das nachfolgende Beispiel veranschaulicht die Anwendung der Include-Methode.

   1: using System;

   2: using Microsoft.SharePoint.Client;

3:

   4: class Program

   5: {

   6:    static void Main(string[] args)

   7:    {

   8:       ClientContext clientContext = new ClientContext("http://win7-fm-t400");

   9:       Web web = clientContext.Web;

  10:       List list = web.Lists.GetByTitle("Customers");

  11:       ListItemCollection allItems = list.GetItems(new CamlQuery()

  12:                                           { ViewXml = "<View/>" });

13:

  14:       clientContext.Load(list,

  15:          l => l.Title,

  16:          l => l.ItemCount);

17:

  18:       clientContext.Load(allItems,

  19:          items => items.Include(

  20:             i => i["Title"],

  21:             i => i["FirstName"],

  22:             i => i["Company"]

  23:             ));

24:

  25:       clientContext.ExecuteQuery();

26:

  27:       Console.WriteLine("{0} ({1})", list.Title, list.ItemCount);

28:

  29:       foreach (ListItem i in allItems)

  30:       {

  31:          Console.WriteLine("{0} , {1} ({2})",

  32:             i["Title"],

  33:             i["FirstName"],

  34:             i["Company"]);

  35:       }

  36:    }

  37: }

Der erste Parameter dieses Ausdrucks ist vom Typ ListItemCollection und liefert demnach nicht die Möglichkeit der Filterung der Einzelnen Elemente der Collection. Hierzu muss die erweiterte Include-Methode herangezogen werden. Sie erwartet als Parameter einen Lambda-Ausdruck vom Typ ListItem (Typ der Elemente der Collection) . Der Rückgabewert ist vom Typ IQeryable<ListItem>.

Neben dieser Methode kann zur Einschränkung der Unterelemente einer Collection auch die Methode IncludeWithDefaultProperties genutzt werden. Hiermit können neben den dedizierten Eigenschaften auch die Standardelemente eines Client-Objekts geladen werden.

Datenabfragen via LINQ
Die neue Programmierschnittstelle von SharePoint 2010 liefert auch die Möglichkeit der Datenfilterung via LINQ. Parameter vom Typ IQueryable<T> stellen die erweiterte Methode Where bereit, mit der sich die Elemente der Collection mittels eins LINQ-Ausdrucks filtern lassen. Das nachfolgende Beispiel veranschaulicht die Datenfilterung via LINQ.

   1: using System;

   2: using System.Linq;

   3: using Microsoft.SharePoint.Client;

4:

   5: class Program

   6: {

   7:    static void Main(string[] args)

   8:    {

   9:       ClientContext clientContext = new ClientContext("http://win7-fm-t400");

10:

  11:       Web web = clientContext.Web;

  12:       List list = web.Lists.GetByTitle("Orders");

  13:       ListItemCollection allItems = list.GetItems(new CamlQuery()

  14:                                        { ViewXml = "<View/>" });

15:

  16:       clientContext.Load(allItems,

  17:          items => items.Include(

  18:             i => i["Title"],

  19:             i => i["Amount"],

  20:             i => i["Customer"]

  21:             ).Where(

  22:                i => (int)i["Amount"] >= 10.0)

  23:             );

24:

  25:       clientContext.ExecuteQuery();

26:

  27:       foreach (ListItem i in allItems)

  28:       {

  29:          Console.WriteLine("{0} , {1} ({2})",

  30:             i["Title"],

  31:             i["Amount"],

  32:             ((FieldLookupValue)i["Customer"]).LookupValue);

  33:       }

  34:    }

  35: }

Als Parameter erwartet die Methode einen LINQ-Ausdruck, der den genauen Filter spezifiziert. In diesem Beispiel werden sämtliche Elemente abgefragt bei denen die Menge größer oder gleich dem Wert 10 entspricht. Auch die Rückgabewerte der Include-Methode (vom Typ IQueryable<T>) können über diesen Weg gefiltert werden. Mit diesem grundlegen Konstrukt kann die gesamte Vielfalt von LINQ ausgeschöpft werden, dynamische Datenanfrage aufzubauen.

Zugegeben, das hier beschriebene Bespiel ist nicht unbedingt optimal, weil die Filterung von Objekten des Typs ListItem über LINQ nicht nativ ausgeführt werden können. Bei der Verarbeitung dieser Anfrage wird serverseitig zunächst eine einfache CAML-Abfrage gegen die Quellliste gesendet, dann via LINQ ausgewertet und in Anschluss als JSON zurück an den Client gesendet. Auf die Netzwerklast hat dieses Verhalten keinen Einfluss aber auf die serverseitige Verarbeitung von besonders großen Datenmengen. Wenn man bei der Anfrage an den Server mal den SQL Profiler mitlaufen lässt, kann man sehr gut erkennen, dass über eine Stored Procedure erst einmal sämtliche Daten eingelesen und erst dann serverseitig ausgewertet werden. Die Filterung von Listenelementen sollte daher in keinem Fall via LINQ sondern über CAML realisiert werden.

Datenabfragen via CAML
Natürlich können Daten auch klassisch via CAML abgefragt werden. Die Methode ListItemCollection.GetItems erwartet als Parameter eine CAML-Abfrage, die durch den Typ CamlQuery repräsentiert wird. Das nachfolgende Beispiel beschreibt, wie die ineffiziente LINQ-Abfrage des vorangegangenen Beispiels über CAML abgebildet werden kann.

   1: using System;

   2: using System.Linq;

   3: using Microsoft.SharePoint.Client;

4:

   5: class Program

   6: {

   7:    static void Main(string[] args)

   8:    {

   9:       ClientContext clientContext = new ClientContext("http://win7-fm-t400");

10:

  11:       Web web = clientContext.Web;

  12:       List list = web.Lists.GetByTitle("Orders");

  13:       ListItemCollection allItems = list.GetItems(new CamlQuery()

  14:       {

  15:          ViewXml = @" <View>

  16:                            <Query>

  17:                               <Where>

  18:                                  <Geq>

  19:                                     <FieldRef Name='Amount'/>

  20:                                     <Value Type='Integer'>10</Value>

  21:                                  </Geq>

  22:                               </Where>

  23:                            </Query>

  24:                            <RowLimit>100</RowLimit>

  25:                         </View>"

  26:       });

27:

  28:       clientContext.Load(allItems,

  29:          items => items.IncludeWithDefaultProperties(

  30:             i => i["Article"],

  31:             i => i["Amount"],

  32:             i => i["Customer"])

  33:             );

34:

  35:       clientContext.ExecuteQuery();

36:

  37:       foreach (ListItem i in allItems)

  38:       {

  39:          Console.WriteLine("{0} , {1} ({2})",

  40:             i["Article"],

  41:             i["Amount"],

  42:             ((FieldLookupValue)i["Customer"]).LookupValue);

  43:       }

  44:    }

  45: }

Load vs. LoadQuery
In diesem Artikel bisher gänzlich unerwähnt blieb die Methode ClientContext.LoadQuery, die anstelle von Load für die Abfrage von Client-Objekten verwendet werden kann. Der Funktionsumfang und die Verwendung dieser Methode sind vergleichbar mit der von Load, einzig die Befüllung des Client-Objekts ist anders. Wo bei der Load-Methode direkt das Client-Objekt mit Daten gefüllt wird, liefert LoadQuery eine komplett neue Collection vom Typ IQueryable<T> zurück. Ein wesentlicher Vorteil dieser Methode ist die Möglichkeit, mehrere Abfragen gegen dasselbe Client-Objekt auszuführen.

   1: using System;

   2: using System.Linq;

   3: using Microsoft.SharePoint.Client;

   4: using System.Collections.Generic;

5:

   6: class Program

   7: {

   8:    static void Main(string[] args)

   9:    {

  10:       ClientContext clientContext = new ClientContext("http://win7-fm-t400");

  11:       Web web = clientContext.Web;

  12:       List list = web.Lists.GetByTitle("Customers");

13:

  14:       ListItemCollection allItems = list.GetItems(new CamlQuery()

  15:                            { ViewXml = "<View/>" });

16:

  17:       IEnumerable<ListItem> items = clientContext.LoadQuery(allItems.Include(

  18:             i => i["Title"],

  19:             i => i["FirstName"],

  20:             i => i["Company"]

  21:             ));

22:

  23:       clientContext.ExecuteQuery();

24:

  25:       foreach (ListItem i in items)

  26:       {

  27:          Console.WriteLine("{0} , {1} ({2})",

  28:             i["Title"],

  29:             i["FirstName"],

  30:             i["Company"]);

  31:       }

  32:    }

  33: }

Der Rückgabewert dieser Methode ist vom Typ IEnumerable<T>. Die Elemente der Collection können im Anschluss zum Beispiel über eine foreach-Schleife iteriert werden.

Im letzten Teil dieser Artikelserie werde ich beschreiben, wie mittels des Client-Objektmodells SharePoint-Objekte erzeugt oder manipuliert werden können sowie die Verwaltungen von Benutzern, Gruppen und Berechtigungen.

SharePoint 2010 Administration - Das ein mal eins für den SharePoint-Administrator

Fabian Moritz — Mon, 05 Apr 2010 17:34:36 GMT

Leider fand dieser Artikel in der neuen Ausgabe des SharePoint Magazins keinen Platz mehr. Daher möchte ich ihn an dieser Stelle veröffentlichen. Viel Spaß beim Lesen!

SharePoint 2010 stellt eine robuste, intuitive Anwendungsplattform bereit, die dem Administrator einen tiefen Einblick in die operativen Prozesse verschafft. Eine komplett überarbeitete Zentraladministration, verbesserte Migrations-, Sicherungs- und Überwachungswerkzeuge, eine bessere Kontrolle von Serverressourcen sowie die Unterstützung von PowerShell machen die Administration von SharePoint-Umgebungen in Zukunft deutlich komfortabler. Dieser Artikel stellt Ihnen die wichtigsten neuen Funktionen in SharePoint 2010 für den Administrator vor.

Installation
Der gesamte Installationsprozess von SharePoint Foundation 2010 oder SharePoint Server 2010 geht mit der neuen Produktversion deutlich leichter von der Hand. Die wohl wichtigste Verbesserung ist der Prerequsites Installer, der dem Administrator die aufwändige Arbeit der manuellen Installation und Konfiguration der Systemvoraussetzungen abnimmt.

Der Anwender kann entscheiden, ob die für die Installation erforderlichen Komponenten heruntergeladen oder von einem lokalen Verzeichnis installiert werden sollen. Neben der aus den Vorversionen bekannten grafischen Installationsoberfläche, die sich im Wesentlichen nicht verändert hat, steht dem Administrator auch die Option bereit, die SharePoint-Umgebung via PowerShell zu installieren. Die zweite Variante liefert eine deutlich feinere Konfigurationsmöglichkeit und dem Nutzer mehr Einfluss auf den eigentlichen Installationsprozess. Neu ist auch ein zentrales Farm-Kennwort, mit dem sämtliche Kommunikationswege zwischen den Servern einer SharePoint-Farm verschlüsselt werden. Das während der Installation festgelegte Kennwort wird in einen sicheren Bereich abgespeichert und ggf. kann im Nachhinein über PowerShell geändert werden.

Upgrade
Eines der Hauptschwachpunkte von SharePoint 2007 waren die fehlenden und nur sehr mangelhalfen Upgrade-Möglichkeiten, wodurch Migrationsprojekte in der Regel mit einem erheblichen Aufwand verbunden waren. Mit der Umsetzung der neuen Produktversion wurde der Fokus besonders auf diesen Bereich gelegt und neue verbesserte Funktionen für eine saubere und fehlerfreie Migration einer SharePoint 2007-Umgebung integriert. Bereits mit dem Service Pack 2 von SharePoint 2007 wurde einer der Grundbausteine hierfür gelegt. Die STSADM-Erweiterung preupgradecheck ermöglicht die Auswertung wesentlicher Eckdaten und potentieller Probleme einer SharePoint-Farm für eine mögliche Migration.

SharePoint 2010 stellt zwei grundlege Upgrade-Methoden zur Verfügung. Die In-Place oder Database Attach-Methode. Beim In-Place Upgrade wird eine bestehende SharePoint 2007-Farm nach SharePoint 2010 direkt migriert. Bei der Database Attach-Variante wird eine gesicherte Inhaltsdatenbank einer komplett neuen SharePoint 2010-Farm angehangen und in diesem Prozess aktualisiert. Das In-Place Upgrade sollte nur bei kleinen (nicht angepassten) Farmen oder Single Server-Installationen durchgeführt werden. Den deutlich flexibleren Weg liefert das Database Attach-Upgrade. Eine Ergänzung zum Pre-Upgrade Check liefert das PowerShell cmdlet Test-SPContentDatabase. Das Script untersucht das Zusammenspiel zwischen den zu migrierenden Inhaltsdatenbanken und der neuer Farm und kann hierbei zum Beispiel fehlende Solutions, Features oder Assemblies bzw. verwaiste Daten identifizieren.

Eine weitere wichtige Verbesserung in diesem Bereich ist das sogenannte Visual Upgrade. Die Technologie unterstützt die Migration bestehender Masterseiten oder Style Sheets. Bei dem Verfahren werden zunächst die alten Masterseiten und Style Sheets angewandt. Der Benutzer kann direkt in der Administrationsoberfläche der Websitesammlung das neuen Design überprüfen und dann ggf. anwenden.

Sämtliche während des Upgrades durchgeführten Arbeitsschritte werden in einem verbesserten, standardisierten Verfahren protokolliert.

Zentraladministration
Die Zentraladministration präsentiert sich in einem komplett überarbeiteten Outfit. Eine Restrukturierung der Menüs und die Integration des Ribbons sollen das Auffinden von Funktionen für den Administrator in Zukunft einfacher gestalten. Gewöhnungsbedürftig ist der Umstand, dass einige Funktionen über die Ribbon-Oberfläche (zum Beispiel die Verwaltung von Webanwendungen) und andere Einstellungen wiederum im Inhaltsbereich der Zentraladministration untergebracht sind. Bereits mit den ersten Arbeitsschritten in der Zentraladministration wird spürbar, dass der Weg zu einer Einstellung deutlich kürzer ist als in der Vorversion.

Eine neue Funktion in der Zentraladministration ist der sogenannte Configuration Wizard, der den Administrator bei der Einrichtung der SharePoint-Dienste und Service Accounts unterstützen soll. Erfahrene Administratoren werden vermutlich auf diese Funktion verzichten können, da sie hierüber nur wenig Einfluss auf die Konfiguration der einzelnen Dienste haben.

Managed Services
SharePoint 2010 führt ein komplett neues Service-Modell ein. Die Managed Services sind der Nachfolger vom Shared Service Provider des Office SharePoint Server 2007. Anders als in der Vorversion, sind die Services bereits in SharePoint Foundation 2010 integriert und damit fester Bestandteil der SharePoint-Architektur. Sämtliche verteilbare SharePoint-Dienste werden über diese Ebene abgedeckt. Drei seiner bekanntesten Vertreter sind die Suche, der Profilimport oder die Business Connectivity Services. Die Administration der Managed Services erfolgt über die Zentraladministration oder PowerShell. Hierüber können die Anwendungsidentitäten und ggf. benutzerdefinierten Einstellungen der Dienste konfiguriert werden. In großen Umgebungen können die Services auf unterschiedliche Anwendungsserver verteilt werden.

Sicherung und Wiederherstellung
Die Backup- und Restore-Funktionen wurden in SharePoint 2010 deutlich verbessert. Die neue Version unterstützt die Erstellung von granularen Sicherungen von Websitesammlungen, Webseiten oder auch Listen direkt über der Zentraladministration. In der Vorversion war diese Option nur dem STSADM-Kommandozeilenwerkzeug vorbehalten.

Neben der Zentraladministration können Sicherungsprozesse auch über PowerShell gesteuert werden. Die zweite Variante bieten im Vergleich zur Zentraladministration deutlich mehr Flexibilität und Einfluss. Zum Beispiel kann der Administrator hierüber auf die Dateikompression oder die Verwendung von SQL Snapshots Einfluss nehmen.

Eine interessante Neuerung ist die Wiederherstellung von ungebundenen Inhaltsdatenbanken. Was bedeutet das? In SharePoint 2007 ist es möglich, auf Basis einer SQL Server-Sicherung die Wiederherstellung einer Inhaltsdatenbank durchzuführen. Hierbei werden sämtliche in der Datenbank enthaltenen Elemente überschrieben. Sollte in einem Anwendungsfall nur eine Liste oder Webseite wiederhergestellt werden, ist dieses Verfahren nicht unbedingt optimal. Mit der neuen Funktion der Wiederherstellung von ungebundenen Inhaltsdatenbanken bekommt der Administrator die Option, aus der Sicherung der Inhaltsdatenbank sehr granular auszuwählen, welche Elemente er wiederherstellen möchte.

Wartung und Überwachung
SharePoint 2010 integriert eine Reihe neuer Funktionen, die den Administrator bei der Überwachung und Wartung von SharePoint-Farmen unterstützen. Zu den wichtigsten Funktionen gehören ein neuer Unified Logging Service (ULS), eine neu konzipierte Logging-Datenbank, neue Monitoring-Funktionen oder die Unterstützung von System Center Operations Manager (SCOM). Für die Auswertung von SharePoint-Ereignissen wurde der sogenannte Unified Logging Service (ULS) in die Plattform integriert. Die von SharePoint zu überwachenden Ereignisse können sehr granular über die Einstellungen der Zentraladministration gesteuert werden. Die Anzahl der unterstützten Events wurde im Vergleich zur Vorversion noch einmal deutlich erhöht.

Eine neu eingeführte Correlation ID machen das Auffinden und die Zuweisung von Ereignissen, Warnungen oder Fehler über Servergrenzen hinweg in Zukunft spürbar einfacher. Sämtliche Ereignisse von SharePoint oder Drittanbieter-Diensten werden auf Ebene des ULS gesteuert. Durch die Verwendung der NTF-Kompression werden die Logdateien in SharePoint 2010 um ca. 50 % reduziert. Die Auswertung von Logdateien kann in SharePoint 2010 durch PowerShell oder einem von Microsoft kostenlos bereitgestellten ULS Viewer (http://code.msdn.microsoft.com/ULSViewer) durchgeführt werden. Wer möchte, kann die Daten natürlich auch über den herkömmlichen Weg mit einem Editor auswerten. Der Unified Logging Service ist vollständig dokumentiert und kann auch von benutzerdefinierten SharePoint-Anwendungen genutzt werden.

Der aus der Vorversion bekannte Best Practice Analyser wird in SharePoint 2010 vollständig integriert. Die unter dem Namen SharePoint Maintenance Engine (SPME) veröffentlichte Erweiterung führt eine auf Regeln basierte Auswertung von Konfigurationseinstellungen, Performance, Best Practices oder Sicherheitsproblemen durch. Die Ergebnisse werden direkt in der Benutzeroberfläche der Zentraladministration visualisiert.

Eine weitere wichtige Verbesserung in SharePoint 2010 ist die Einführung einer Logging-Datenbank. In dieser Datenbank werden sämtliche Kennzahlen gespeichert, die für eine spätere Auswertung von Bedeutung sein könnten. Dazu gehören zum Beispiel die Seitenaufrufe, Suchanfragen, Verwendung von Features oder Ratings oder die Ausführung von Timer Jobs. Das Schema der Datenbank ist vollständig veröffentlicht. Damit haben Administratoren die Möglichkeit, die Daten in eigenen Berichten oder mit benutzerdefinierten Werkzeugen direkt aus der Datenbank auszulesen und auszuwerten.

PowerShell
SharePoint-Administratoren werden PowerShell in Zukunft wie ihre Westentasche kennen (müssen). Die neue Kommandozeilenoberfläche ist das ultimative Werkzeug für die Administration von SharePoint-Umgebungen. SharePoint 2010 integriert eine Fülle von Standardbefehlen für die Administration - sogenannte cmdlets. Über den Befehl Get-Command –noun sp* können sämtliche cmdlets für SharePoint 2010 ausgegeben werden. Zusammengerechnet sind es über 500 Befehle. Eine weitere für den Einstig in PowerShell sehr wichtige Funktion ist der Befehl Get-Help (Get-Help <cmdlet> [-full] [-detailed]), worüber die Beschreibung eines Befehls aufgerufen werden kann. Die Struktur eines PowerShell Befehls folgt einem festen Muster. Beginnend mit dem Verb (zum Bespiel Add, Get oder Remove) und dem Nomen folgt eine beliebig lange Liste von Parametern und Werten. Die PowerShell-Umgebung für SharePoint lässt sich vollständig Scripten und Erweitern. Jedem SharePoint-Administrator sei an dieser Stelle nahegelegt, sich diese Funktionen anzuschauen.

Bereit für den Administrator
Mit SharePoint 2010 wurden eine Reihe neuer Funktionen für die Administration von SharePoint-Umgebungen in das Produkt integriert. Dem Administrator wird eine aufgeräumte Zentralaministration zur Seite gestellt, mit der er sämtliche Komponenten und Anwendungen einer SharePoint-Farm über einfache Wege administrieren kann. Verbesserungen in den Wartungs- und Überwachungswerkzeugen liefern die Grundlage für einen genauen Einblick in die operativen Prozesse einer SharePoint-Farm. Nicht zuletzt die Unterstützung von PowerShell mit zahlreichen Standardbefehlen ist ein Grund dafür, dass sich der SharePoint-Administrator auf die neue Projektversion von SharePoint freuen kann.