Nella prima parte dell'articolo abbiamo avuto modo di introdurre l'object model di SharePoint e di vedere nel dettaglio le "classi di gestione", che rappresentano gli elementi fondamentali per lo sviluppo di applicazioni integrate con SharePoint. In questa seconda parte continuiamo la presentazione del modello ad oggetti parlando delle "classi di contenuto", ovvero di quegli elementi che consentono di interagire con i contenuti presenti all'interno di un sito SharePoint.

Classi di "contenuto"

Questo insieme di classi ci permette di leggere, aggiungere e manipolare informazioni presenti in un sito SharePoint dalle nostre applicazioni .NET personalizzate (che possono variare da una web part, a un windows service e così via). Queste informazioni possono essere raggruppate in liste, cartelle, elementi di lista, file, utenti, gruppi, permessi, pagine, feature, colonne di sito, content type, alert, template di sito e di lista. Ognuno di questi elementi "logici", che normalmente vengono gestiti dagli utenti finali tramite interfaccia grafica, sono rappresentati da rispettive classi del modello ad oggetti di SharePoint e permettono allo sviluppatore le medesime operazioni presenti all'interno dell'interfaccia grafica di default (e talvolta anche qualcosa in più).

Vediamo quindi quali sono le classi che vengono utilizzate maggiormente durante lo sviluppo di personalizzazioni su piattaforma SharePoint.

Classi SPList/SPListItem

Questa classe rappresenta una singola lista o document library creata all'interno di un sito SharePoint. In generale una lista contiene un elenco di elementi (items) salvati sotto forma di righe, un insieme di colonne, una o più viste ed un insieme di campi (ognuno a rappresentare un particolare tipo di dato). Come avrete quindi intuito, tramite l'object model possiamo manipolare tutti questi insiemi di oggetti a nostro piacimento, possiamo creare e distruggere liste, aggiungere campi, modificare e/o aggiungere viste ed altre operazioni varie, sempre però sottostando ai permessi dell'utente con cui viene eseguito il nostro codice (a meno dell'implementazione di un meccanismo di impersonation).

Come per la classe SPWeb, anche SPList non ha un costruttore pubblico. Una nuova istanza di tale classe può essere però prelevata dal contesto (sempre tramite la classe SPContext) oppure dalle seguenti proprietà e metodi della classe SPWeb:

• proprietà Lists: collezione di tutte le liste del sito;
• metodo GetList: ritorna la lista in base all'url passato come parametro;
• metodo GetListFromWebPartPageUrl: ritorna la lista legata alla prima web part trovata nel pagina passata come parametro.

SPSite site = new SPSite("http://servername");

using (site)
{
  SPWeb web = site.OpenWeb();

  using (web)
  {
    // Lista prelevata dal contesto
    SPList currentList = SPContext.Current.List;

    // Lista prelevata dall'oggetto SPWeb
    SPList list = web.Lists["Test"];
    SPList list2 = web.GetList("http://servername/Lists/Test/");
    SPList list3 =
      web.GetListFromWebPartPageUrl("http://servername/Lists/Test/NewForm.aspx");
  }
}

Con un'istanza della classe SPList possiamo procedere a leggerne gli elementi. Anche in questo caso abbiamo vari metodi per enumerare tutti gli elementi: possiamo utilizzare la proprietà Items oppure il metodo GetItems; entrambi comunque ci ritornano un'istanza della classe SPListItemCollection (collezione di elementi di tipo SPListItem) che possiamo così scorrere a nostro piacimento.

Ogni elemento poi espone alcune proprietà di base che sono comuni a tutti gli elementi di tutti i tipi di liste, mentre per le proprietà custom (che sarebbero i relativi campi creati all'interno della lista che stiamo scorrendo) la classe SPListItem ci offre un indexer che ci permette di recuperare i valori passando l'indice, il Guid del campo o il suo internal name (che sarebbe il nome che SharePoint salva internamente per ogni campo di una lista).

using (SPSite site = new SPSite("http://servername"))
{
  using (SPWeb web = site.OpenWeb())
  {       
    // Lista di tipo calendario 
    SPList list = web.Lists["Test"];

    foreach (SPListItem item in list.Items)
    {
      // Proprietà comuni a tutti gli item
      Console.WriteLine("Title: {0}", item.Title);
      Console.WriteLine("Name: {0}", item.Name);
      Console.WriteLine("ID: {0}", item.ID);            
    }

    foreach (SPListItem item in list.GetItems(list.DefaultView))
    {
      // Proprietà custom
      Console.WriteLine("{0}", item["Location"]);
      Console.WriteLine("{0}", item["EventDate"]); // Colonna "Start Date"
    }
  }
}

Così come possiamo scorrere gli elementi di una lista, ne possiamo leggere le cartelle. Questo è possibile perché all'interno di un qualsiasi tipo di lista SharePoint, se abilitate, possono essere create una o più cartelle a formare una struttura ad albero per dividere maggiormente i vari elementi posti al suo interno. Ogni cartella nel modello ad oggetti di SharePoint è rappresentata dalla classe SPFolder.

using (SPSite site = new SPSite("http://servername"))
{
  using (SPWeb web = site.OpenWeb())
  {
    SPList list = web.Lists["Test"];

    // Elenco delle cartelle
    foreach (SPFolder folder in list.Folders)
    {
      Console.WriteLine("Folder: {0}", folder.Name);
      foreach (SPFile file in folder.Files)
      {
        Console.WriteLine("- {0}", file.Name);
      }
    }
  }
}