Mapowanie SPListItem na obiekt – Wrapper

Może zainteresują Cię pozostałe posty z cyklu Mapowanie SPListItem na obiekt:

1. Mapowanie SPListItem na obiekt – Wprowadzenie
2. Mapowanie SPListItem na obiekt – Wrapper (aktualnie czytasz)
3. Mapowanie SPListItem na obiekt – implicit/explicit conversion
4. Mapowanie SPListItem na obiekt – LINQ to SharePoint
5. Mapowanie SPListItem na obiekt – AutoMapper
6. Mapowanie SPListItem na obiekt – Field Mapper

W poprzedniej części opisałem sposób dostępu do obiektu SPListItem za pomocą braku mapowania – dostęp odbywał się bezpośrednio przez obiekt SPListItem. W drugiej części opiszę to, co zastosowaliśmy w jednym z niesławnych projektów w 2007 roku.

W wspomnianym projekcie, jak tylko zorientowaliśmy się, że SharePoint nie posiada silnie typowanych pól, stwierdziliśmy, że trzeba coś z tym zrobić. Jako że czas gonił a na temat SPS w tych czasach prawie w ogóle postów nie było wymyśliliśmy najszybszy sposób silnie typowanego dostępu do danych jaki mogliśmy wykonać w krótkim czasie – wrapper. Cały kod i przykłady użyte w postcie pochodzą z okresu 2007 roku. Chciałbym to po prostu zaznaczyć :)

Wrapper

Mówiąc krótko, wrapper opakowuje dostęp do elementów poprzez zunifikowany interfejs starając się ukryć poorly designed or complicated interface.

To co chcieliśmy osiągnąć to podmienić wywołanie SPListItem[„Name”] na ClassName.Name a przy tym udostępnić prosty, zunifikowany dostęp do danych. Nie interesował nas przy tym typ zwracanych danych – to znaczy, mogliśmy żyć z tym iż zostanie nam zwrócony obiekt SPFieldLookupValue czy SPFieldUserValue, zaś co do pozostałych to chcieliśmy by dane zwrócone były value type.

Czyli do prostej listy z tytułem (pole wymagane) oraz liczbą (pole niewymagane) chcieliśmy mieć następujący dostęp:

public partial interface IItemEntity
{				
    int Id { get; }
    Guid UniqueId { get; }
    DateTime Created { set; get; }
    DateTime Modified { set; get; }
    SPAttachmentCollection Attachments { get; }
    string Title { set; get; }
    SPFieldUserValue Author { set; get; }
    double? Number { set; get; }
    SPFieldUserValue Editor { set; get; }
}

Także chcieliśmy mieć możliwość tworzenia, aktualizacji i usuwania obiektów za pomocą wrappera:

public partial class ItemEntity : IItemEntity
{
    private SPListItem _spListItem;

    public ItemEntity(SPListItem listItem)
    {
	    if(listItem == null)
	    {
		    throw new ArgumentNullException("listItem");
	    }
    				
	    this._spListItem = listItem;
    }

    public ItemEntity()
    {
	    SPSite spSite = SPContext.Current.Site;
	    SPWeb spWeb = spSite.OpenWeb(ItemEntityConsts.Web);
	    SPList spList = spWeb.Lists[ItemEntityConsts.List];
	    this._spListItem = spList.Items.Add();
    }

    public ItemEntity(SPWeb web)
    {
	    if(web == null)
	    {
		    throw new ArgumentNullException("web");
	    }
    	
	    SPSite spSite = web.Site;
    	
	    SPWeb spWeb = spSite.OpenWeb(ItemEntityConsts.Web);
	    SPList spList = spWeb.Lists[ItemEntityConsts.List];
    	
	    this._spListItem = spList.Items.Add();
    }
    		
    public void Update()
    {
	    this._spListItem.Update();			
    }

    public void Delete()
    {
	    this._spListItem.Delete();
    }
   
    // ... usuniete properties
}

Jednakże sam wrapper nie dawał nam pełnych możliwości, musieliśmy dorobić jeszcze data access layer, który udostępniał nam metody operujące na obiekcie lub kolekcji obiektów – teraz taki layer można by nazwać repozytorium.

public partial interface IItemDataAccess
{
    ICollection<IItemEntity> Items { get; }

    ICollection<IItemEntity> GetItemsByQuery(string query);
    ICollection<IItemEntity> GetItemsByQuery(string query, SPWeb web);
    ICollection<IItemEntity> GetItemsByQuery(string query, int limit);
    ICollection<IItemEntity> GetItemsByQuery(string query, int limit, SPWeb web);
    IItemEntity GetItemById(int id);
    IItemEntity GetItemById(int id, SPWeb web);
    IItemEntity GetItemByUniqueId(Guid uniqueId);
    IItemEntity GetItemByUniqueId(Guid uniqueId, SPWeb web);
    IItemEntity CreateItemInstance();
    IItemEntity CreateItemInstance(SPWeb web);		
    IItemEntity CreateItemInstance(SPListItem listItem);
}

Podsumowując, całość interfejsów wyglądała tak:

// IDki pol
internal static class ItemEntityConsts
{
    internal static Guid Title = new Guid("fa564e0f-0c70-4ab9-b863-0177e6ddd247"); 
    internal static Guid Author = new Guid("1df5e554-ec7e-46a6-901d-d85a3881cb18"); 
    internal static Guid Number = new Guid("342bae15-79ae-4773-8039-7ff651579928"); 
    internal static Guid Editor = new Guid("d31655d1-1d5b-4511-95a1-7a09e9b75bf2"); 
    internal static string Created = "Created"; 
    internal static string Modified = "Modified"; 
    internal static string Web = "/"; 
    internal static string List = "Items";
}

// interfejs dla entity
public partial interface IItemEntity
{
    int Id { get; }    
    Guid UniqueId { get; }    
    DateTime Created { set; get; }    
    DateTime Modified { set; get; }    
    SPAttachmentCollection Attachments { get; }    
    string Title { set; get; }    
    SPFieldUserValue Author { set; get; }    
    double? Number { set; get; }    
    SPFieldUserValue Editor { set; get; }    
    void Update();    
    void Delete();
}
// interfejs dostepu do danych
public partial interface IItemDataAccess
{
    ICollection<IItemEntity> Items { get; }    
    ICollection<IItemEntity> GetItemsByQuery(string query);    
    ICollection<IItemEntity> GetItemsByQuery(string query, SPWeb web);    
    ICollection<IItemEntity> GetItemsByQuery(string query, int limit);    
    ICollection<IItemEntity> GetItemsByQuery(string query, int limit, SPWeb web);    
    IItemEntity GetItemById(int id);    
    IItemEntity GetItemById(int id, SPWeb web);    
    IItemEntity GetItemByUniqueId(Guid uniqueId);    
    IItemEntity GetItemByUniqueId(Guid uniqueId, SPWeb web);    
    IItemEntity CreateItemInstance();    
    IItemEntity CreateItemInstance(SPWeb web);		    
    IItemEntity CreateItemInstance(SPListItem listItem);
}

Implementacja ItemEntity tak:

public partial class ItemEntity : IItemEntity
{
    private SPListItem _spListItem;

    public ItemEntity(SPListItem listItem)
    {
        if (listItem == null)
        {
            throw new ArgumentNullException("listItem");
        }

        this._spListItem = listItem;
    }

    public ItemEntity()
    {
        SPSite spSite = SPContext.Current.Site;
        SPWeb spWeb = spSite.OpenWeb(ItemEntityConsts.Web);
        SPList spList = spWeb.Lists[ItemEntityConsts.List];
        this._spListItem = spList.Items.Add();
    }

    public ItemEntity(SPWeb web)
    {
        if (web == null)
        {
            throw new ArgumentNullException("web");
        }

        SPSite spSite = web.Site;

        SPWeb spWeb = spSite.OpenWeb(ItemEntityConsts.Web);
        SPList spList = spWeb.Lists[ItemEntityConsts.List];

        this._spListItem = spList.Items.Add();
    }

    public void Update()
    {
        this._spListItem.Update();
    }

    public void Delete()
    {
        this._spListItem.Delete();
    }
    				
    public int Id 
    { 
        get { return this._spListItem.ID; } 
    }

    public Guid UniqueId
    {
        get { return this._spListItem.UniqueId; }
    }

    public DateTime Created
    {
        set { this._spListItem[ItemEntityConsts.Created] = value; }
        get { return (DateTime)this._spListItem[ItemEntityConsts.Created]; }
    }

    public DateTime Modified
    {
        set { this._spListItem[ItemEntityConsts.Modified] = value; }
        get { return (DateTime)this._spListItem[ItemEntityConsts.Modified]; }
    }

    public SPAttachmentCollection Attachments
    {
        get { return this._spListItem.Attachments; }
    }

    public string Title	
    {
        set
        {
            if(string.IsNullOrEmpty(value))
            {
                throw new ArgumentNullException("value");
            }					

            this._spListItem[ItemEntityConsts.Title] = value;
        }
        get
        {
            try
            {
                return (string)this._spListItem[ItemEntityConsts.Title];
            }
            catch(InvalidCastException ex) 
            {
                string message = string.Format(CultureInfo.InvariantCulture, ExceptionMessages.EntityStrongTypingException, "ItemEntityConsts.Title", "Items");
                throw new System.Data.StrongTypingException(message, ex);
            }
        }
    }
    	
    public SPFieldUserValue Author	
    {
        set
        {
            this._spListItem[ItemEntityConsts.Author] = value;
        }
        get
        {
            try
            {
                if(this._spListItem[ItemEntityConsts.Author] != null)
                {
                    return new SPFieldUserValue(this._spListItem.Web, this._spListItem[ItemEntityConsts.Author].ToString());
                }
                else
                {
                    return null;
                }
            }
            catch(InvalidCastException ex) 
            {
                string message = string.Format(CultureInfo.InvariantCulture, ExceptionMessages.EntityStrongTypingException, "ItemEntityConsts.Author", "Items");
                throw new System.Data.StrongTypingException(message, ex);
            }
        }
    }

    public double? Number
    {
        set
        {
            this._spListItem[ItemEntityConsts.Number] = value;
        }
        get
        {
            try
            {
                return (double?)this._spListItem[ItemEntityConsts.Number];
            }
            catch(InvalidCastException ex) 
            {
                string message = string.Format(CultureInfo.InvariantCulture, ExceptionMessages.EntityStrongTypingException, "ItemEntityConsts.Number", "Items");
                throw new System.Data.StrongTypingException(message, ex);
            }
        }
    }

    public SPFieldUserValue Editor	
    {
        set
        {
            this._spListItem[ItemEntityConsts.Editor] = value;
        }
        get
        {
            try
            {
                if(this._spListItem[ItemEntityConsts.Editor] != null)
                {
                    return new SPFieldUserValue(this._spListItem.Web, this._spListItem[ItemEntityConsts.Editor].ToString());
                }
                else
                {
                    return null;
                }
            }
            catch(InvalidCastException ex) 
            {
                string message = string.Format(CultureInfo.InvariantCulture, ExceptionMessages.EntityStrongTypingException, "ItemEntityConsts.Editor", "Items");
                throw new System.Data.StrongTypingException(message, ex);
            }
        }
    }
}

Implementacja Data Access zaś tak:

public partial class ItemDataAccess : IItemDataAccess
{
    public ICollection<IItemEntity> Items
    {
	    get { return this.GetItemsByQuery("", -1); }
    }

    public ICollection<IItemEntity> GetItemsByQuery(string query)
    {
	    return this.GetItemsByQuery(query, -1);
    }

    public ICollection<IItemEntity> GetItemsByQuery(string query, SPWeb web)
    {
	    return this.GetItemsByQuery(query, -1, web);
    }

    public ICollection<IItemEntity> GetItemsByQuery(string query, int limit)
    {
        ICollection<IItemEntity> list = new Collection<IItemEntity>();

        SPSite spSite = SPContext.Current.Site;

        using(SPWeb spWeb = spSite.OpenWeb(ItemEntityConsts.Web))
        {
            SPList spList = spWeb.Lists[ItemEntityConsts.List];

            SPQuery spQuery = new SPQuery();

            spQuery.Query = query;

            if(limit >= 0)
            {
                spQuery.RowLimit = (uint)limit;			
            }

            SPListItemCollection listItems = spList.GetItems(spQuery);

            foreach(SPListItem listItem in listItems)
            {
                list.Add(new ItemEntity(listItem));
            }

            return list;
        }
    }

    public ICollection<IItemEntity> GetItemsByQuery(string query, int limit, SPWeb web)
    {
        if(web == null)
        {
            throw new ArgumentNullException("web");
        }

        ICollection<IItemEntity> list = new Collection<IItemEntity>();

        SPSite spSite = web.Site;

        using(SPWeb spWeb = spSite.OpenWeb(ItemEntityConsts.Web))
        {
            SPList spList = spWeb.Lists[ItemEntityConsts.List];

            SPQuery spQuery = new SPQuery();

            spQuery.Query = query;

            if(limit >= 0)
                spQuery.RowLimit = (uint) limit;			

            SPListItemCollection listItems = spList.GetItems(spQuery);

            foreach(SPListItem listItem in listItems)
            {
                list.Add(new ItemEntity(listItem));
            }

            return list;
        }
    }

    public IItemEntity GetItemById(int id)
    {
        SPSite spSite = SPContext.Current.Site;

        using(SPWeb spWeb = spSite.OpenWeb(ItemEntityConsts.Web))
        {
            SPList spList = spWeb.Lists[ItemEntityConsts.List];

            return new ItemEntity(spList.GetItemById(id));
        }
    }

    public IItemEntity GetItemById(int id, SPWeb web)
    {
        if(web == null)
        {
            throw new ArgumentNullException("web");
        }

        SPSite spSite = web.Site;

        using(SPWeb spWeb = spSite.OpenWeb(ItemEntityConsts.Web))
        {
            SPList spList = spWeb.Lists[ItemEntityConsts.List];

            return new ItemEntity(spList.GetItemById(id));
        }
    }

    public IItemEntity GetItemByUniqueId(Guid uniqueId)
    {
        SPSite spSite = SPContext.Current.Site;

        using(SPWeb spWeb = spSite.OpenWeb(ItemEntityConsts.Web))
        {
            SPList spList = spWeb.Lists[ItemEntityConsts.List];

            return new ItemEntity(spList.GetItemByUniqueId(uniqueId));
        }
    }

    public IItemEntity GetItemByUniqueId(Guid uniqueId, SPWeb web)
    {
        if(web == null)
        {
            throw new ArgumentNullException("web");
        }

        SPSite spSite = web.Site;

        using(SPWeb spWeb = spSite.OpenWeb(ItemEntityConsts.Web))
        {
            SPList spList = spWeb.Lists[ItemEntityConsts.List];

            return new ItemEntity(spList.GetItemByUniqueId(uniqueId));
        }
    }

    public IItemEntity CreateItemInstance()
    {
        return new ItemEntity();
    }

    public IItemEntity CreateItemInstance(SPWeb web)
    {
        return new ItemEntity(web);
    }

    public IItemEntity CreateItemInstance(SPListItem listItem)
    {
        return new ItemEntity(listItem);
    }
}

Wady

• Rozwiązanie jest dość ciężkie, i działa na obiektach SharePoint cały czas;
• Przy posiadaniu własnych pól musimy je zwracać zamiast domyślnych wartości – wymaga edycji;
• Nie możemy obiektu przekazać gdzie indziej ze względu na powiązanie do modelu obiektowego SharePoint;
• Trzeba pamiętać o wykonaniu Update;
• Brak zarządzania stanem – możliwość dostępu do danych nie istniejących lub do danych już zmienionych.

Zalety

• Szybki i sprawny, silnie typowany dostęp do modelu obiektowego SharePoint;
• Silne typowanie;
• Dzięki interfejsowi, możliwe kilka implementacji;
• W porównaniu z brakiem mappowania, jedno miejsce dostępu (dzięki czemu wystarczy, że zmienimy kod w wrapperze);
• Pomoc kompilatora, jeżeli typ danych zwracanych jest różny – brak tej opcji w braku mappowania np.: var a = item[“name”], czym tutaj jest a?

Rozwiązanie

Ze względu na rozmiar projektu, nikt z nas nie chciał klepać tego kodu – przy jednej czy dwóch listach nie ma problemu, ale przy 50… co łącznie daje minimum 50*5=250 plików może to być trochę uciążliwe. Na szczęście z pomocą przyszedł nam CodeSmith Tools, dzięki któremu w dwa dni napisaliśmy sobie klasy generujące kod a potem jedynie konfigurację do naszych istniejących list.

Szablon, który użyliśmy załączam do postu – może komuś się przyda. Problem polega na tym iż był on pisany w lutym 2007 roku, a ostatnia jego aktualizacja była w lipcu 2007 roku i szczerze mówiąc nie pamiętam czy aby na pewno wszystkie typy pól SharePointa były w nim dobrze obsłużone :( Powyższy przykład został wygenerowany właśnie za pomocą tego narzędzia, więc na pewno działa (przynajmniej częściowo). Na rzecz tego postu trochę go zmodyfikowałem – usunąłem jeden poziom dostępu do danych, który istniał u nas jednak nie jest wymagany do poprawnego dostępu do danych. Także wykasowałem nazwę projektu z plików (na wszelki wypadek).

Rozwiązanie składa się z następujących plików:

• CommonScript.cs – udostępnia proste operacje na przestrzeni nazw oraz widoczności elementów;
• ProjCommonScript.cs – tworzy tablicę nazw pól, wykorzystywaną w pozostałych plikach;
• ProjIDataAccess.cst – szablon generujący interfejs dostępu do danych;
• ProjDataAccess.cst – szablon generujący implementację interfejsu dostępu do danych;
• ProjEntitiesConsts.cst – GUIDy dostępu do pól;
• ProjIEntities.cst – szablon generujący interfejs encji;
• ProjEntities.cst – szablon generujący implementację interfejsu encji;
• Proj.ClassGenerator.cst – szablon uruchamiający pozostałe szablony z przekazanymi ustawieniami generowania;
• Proj.CommonSettings.cst – definicja parametrów generowania szablonów;
• Gen_List_Settings.csp – przykładowe wartości parametrów z możliwością wygenerowania kodu.

Przykładowe parametry (sposób konfiguracji):

<?xml version="1.0"?>
<codeSmith xmlns="http://www.codesmithtools.com/schema/csp.xsd">
  <propertySets>
    <propertySet template="Proj.ClassGenerator.cst">
      <property name="SharePointSite">http://URL TO SPS SITE</property>
      <property name="SharePointWeb">/[URL TO WEB IF ANY]</property>
      <property name="SharePointList">LIST NAME</property>
      <property name="OutputDirectory">_GenOutput FOLDER</property>
      <property name="ClassName">CLASS NAME</property>
      <property name="Accessibility">Public</property>
      <property name="IncludeNamespaces">True</property>
      <property name="ModuleName">DONT REMEMBER</property>
      <property name="ReturnAllItems">NAZWA WIELU ELEMENTOW NP Items</property>
      <property name="ReturnSingleItem">NAZWA JEDNEGO ELEMENTU NP Item</property>
    </propertySet>
  </propertySets>
</codeSmith>

Po skonfigurowaniu pliku CSP, klikamy na niego prawym przyciskiem myszy i wybieramy opcję Generate Outputs:

UWAGA: Szablon udostępniony jest na zasadach „AS IS”, bez gwarancji, że będzie on działał. Jeżeli jednak zdecydujecie się na to podejście i będziecie mieć problem z szablonem, dajcie znać w miarę możliwości postaram się pomóc.

WrapperGenerator.zip (13.38 kb)