SharePointCommunity
Die deutschsprachige Community für SharePoint, Microsoft 365, Teams, Yammer und mit Azure
SharePoint 2010 Client Objektmodell – Erweiterte Anwendungsbeispiele

Blogs

Fabian´s Blog [SharePoint MVP]

Syndication

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.


Bereitgestellt 3 Mai 2010 20:07 von Fabian Moritz