Code Segment

Cenando

El otro día paso Unai por Pamplona y estuvimos cenando y departiendo sobre todas esas cosas frikis que nos gustan. Una suerte para los que habéis podido asistir a los cursos que ha impartido de Entity Framework  y WCF.

Durante la cena, [[degustábamos unos “Penne Arrabiata” (no seáis mal pensados, que son macarrones con tomate un poco picante) y un “Ochoa Tempranillo” (recomendado)]], hablamos de; libros, de código, de más código, de bugs, de depuración, de tecnología, del bien y del mal (lo típico), no sé si ayer hablamos de sexo (no me acuerdo, pero con el frio que hacía es posible que no :-).

Bueno, la cosa es que le comenté algunas de las cositas del Api de SharePoint.

¿Buenas Prácticas?

Como ya he contado en alguna ocasión, las colecciones de SharePoint, son a la antigua usanza (Net 1.0), es decir que implementan IEnumerable, en una clase contenida, esto lo hacen en una clase abstracta SPBaseCollection del cual heredan el resto de colecciones de SP.

Bien, hasta el momento no hay mucho problema, es un tema de diseño, necesario para implementar las serializaciones de los objetos además de la persistencia que realiza sharepoint via COM.

Si realicemos una consulta usando SPQuery, (SPQuery nos permite recuperar elementos de una lista usando CAML, que es un meta-lenguaje basado en XML que tiene SharePoint para muchas cosas, entre ellas recuperar elementos de las listas)

<Where>
  <Geq>
    <FieldRef Name=”ID” />
    <Value Type=”Integer”>10</Value>
  </Geq>
</Where>

SPQuery query = new SPQuery
                {
                   Query = "CONSULTITA EN CAML"
                };

SPListItemCollection ítems = lista.GetItems(query);

public SPListItemCollection GetItems(SPQuery query)
{
    return new SPListItemCollection(this, query);
} 

Pero qué pasa si la consulta está mal formada ó es incompleta.  Lo que cabe de esperar es:

1.- Que nos devuelva una excepción en el momento de crear SPQuery (cosa que no hace)
2.- Que nos ofrezca una propiedad o algo para comprobar si la consulta es correcta (cosa que no hace)
3.- Que nos devuelva una colección vacía (cosa que hace peligrosamente a medias)

¿Por qué lo hace a medias? Porque aparentemente nos devuelve una colección vacía, es decir si la consulta está mal, ítems no es null. Pero OJO no es una colección valida.

SPQuery query = new SPQuery
                {
                        Query = "MI mala CAML Query"
                };

SPListItemCollection items = list.GetItems(query);

if (items!= null)
{
    Debug.WriteLine("Soy una colección no nula. Parece que valgo...");
    
    // Ahora reviento
    foreach (SPListItem item in items)
    {
    }
}

Las colecciones de este tipo en SharePoint, son de carga retardada de modo que la colección se carga cuando realmente vamos a usarla (Lazy-Load / Proxy), en ese momento se hace una petición SPRequest que es al que se encarga de recuperar el contenido y obtener la colección de elementos. (fundamento)

En ese momento se usa la consulta SPQuery que le hemos pasado para recuperar los datos, y al tratar de cargarla, como la consulta está mal formada, da una excepción (no advertida ni documentada), y la colección sigue siendo una colección hasta que usemos alguna de sus propiedades o tratemos de recorrerla. Es decir no es una colección vacia, si no una colección donde todo se ha quedado mal inicializado si intentas un items.Count antes de recorrer la colección tambien dará una excepción ya esta va a producirse de igual manera al cargar los datos.

De modo que la buena práctica se convierte en mala práctica ya que se pasa de hacer una comprobación de null antes, a tener que hacer un Try/Catch en el momento de recorrer la colección (como decimos por aquí, cojonudo).

Como alternativa, se puede implementar un método por ejemplo, vía extensión;  para comprobar que la consulta es valida y en caso de no serla que nos devuelva una colección bien formada cuando menos. Otra alternativa podría ser otro método como EnsureCollection, a través del cual podamos recuperar la excepción si nos interesa comunicar que la consulta esta mál formada.

La cosa sería algo así:

public static SPListItemCollection TryGetItems(this SPList list, SPQuery query)
{
    SPListItemCollection items; 

    try
    {
        items = list.GetItems(query);
        int count = items.Count;
    }
    catch(SPException ex)
    {
        query.Query = string.Empty;
        items = list.GetItems(query);                
    }
    
    return items;
}

JA, pero ahí no termina la cosa …  los señores de SharePoint son unos fenómenos optimizando y lo que hacen SPQuery internamente es generar una Vista (propiedad ViewXml de SPQuery), para optimizar el rendimiento, esta vista en Xml, se genera reuniendo todas las propiedades de SPQuery, y se genera siempre y cuando no se ha generado antes (optimización)

De modo, que si cambiamos la propiedad Query de SPQuery, la consulta interna ViewXml no cambia (ya se genero antes), manteniendo la última consulta generada, para lo cual debemos limpiar ViewXml.

query.Query = string.Empty;
query.ViewXml = string.Empty;
items = list.GetItems(query); 

¿Por qué que les habría costado implementar un flag de suciedad y reconstruir la ViewXml cada vez que el objeto este sucio? ¿por qué no documentarlo?

En fin, la cena estuvo genial.

He terminado de leer el último libro de Robert C. Martin, Clean Code. 

De Robert, había leído otros dos libros, “UML para programadores Java”, una guía práctica y sin rodeos de cómo usar UML en proyectos reales; y cuando digo práctica es que no se anda por las ramas y en ocasiones en un tono incluso “irónico” explica perfectamente cómo debemos usar UML.

El otro libro es Agile Principles, Patterns, and Practices in C# (Robert C. Martin Series), que puedo decir de este libro ampliamente comentado, uno de los que se deben tener.  (Ya sabéis que se lo recomiendo a todo el mundo)

Bueno, de modo que “Clean Code: A Handbook of Agile Software Craftsmanship (Robert C. Martin Series) ” tenía todos los boletos de ser un gran libro. No ha defraudado en absoluto.

Apenas empezarlo, en la introducción ya me había pillado. (Ilstración de la introducción)

El libro explica cómo escribir buen código, código legible y eficiente.  Los ejemplos son en Java, pero tener en cuenta que estamos hablando de cómo escribir buen código, habla del significado de los nombres, de las funciones,  de los argumentos, del tipo de retorno, de cómo comentamos el código, de las reglas de formato, de objetos y estructuras de datos, de la gestión de errores, de las pruebas unitarias, del diseño simple, de sistemas, de concurrencia, de refinamiento, de olores y heurística.  Habla de estilo, de buen estilo.

De veras, me ha parecido un libro impresionante, con unos ejemplos claros, con un estilo cuidado y detallado, sin dejar cosas fuera, insistiendo en las cosas importantes (esto a mí me gusta, así entran mejor las cosas)

Vamos un libro que entra de lleno en mi TOPTEN.

Un "poquito" tarde (y con mucha ayudita) os dejo el resumen con todos los detalles del DevCamp en el blog de NavarraDotNet

http://www.navarradotnet.com/post/navarradotnet-en-el-7bdev_camp7d.aspx

Y la información sobre el próximo evento el University Tour

http://www.navarradotnet.com/post/el-University-Tour-viene-a-la-UPNA.aspx 

(Para los que no lo sepan, en la Upna se esta organizando un DotNetClub)

http://www.navarradotnet.com/post/se-esta-cociendo-un-DotNetClub-en-la-UPNA!!.aspx

y como no, siempre vuelve a casa por navidad ... (como el turron)

http://www.navarradotnet.com/post/Chema-Alonso-en-CuatroVientos-Una-sesion-dirigida-a-estudiantes.aspx

Toda la información sobre el paso del Guille por Pamplona (Gracias Guille)

http://www.navarradotnet.com/post/gracias-Guille.aspx

De veras, no sé cómo será el lanzamiento de un producto pero este simple programita que permite comprobar que las disposiciones de objetos SPWeb y SPSite se han realizado correctamente, les ha llevado más de 8 meses desde que algunos la suerte de probar las betas.

Las llamadas que realiza la API de SharePoint, reservando memoria COM, sobre todo cuando se abren sitios y webs, no se libera por medio del recolector de basura del CLR, de modo que debemos liberar las reservas manualmente, esto en ocasiones se nos pasa y como no, tenemos que terminar tirando los servicios para recuperar esos recursos y pasar horas buscando los aujeros.

SP DisposeCheck, usa reflexión y comprueba que en nuestros ensamblados se están haciendo los disposes correctos. Esto en un principio podía dar falsos positivos, cosa que se ha erradicado prácticamente.

Os recomiendo usar esta herramienta encarecidamente, ya que aunque todo se haga bien, no está de más poder comprobarlo. Así que es una de esas que debemos tener…

Para más información aquí

Como sabéis tanto Gustavo como yo llevamos tiempo realizando pruebas sobre lo que programamos en SharePoint, ambos estamos usando TypeMock como framework para nuestros objetos Mocks que son imprescindibles a la hora de realizar pruebas para SharePoint.

Durante los últimos meses hemos posteado sobre el tema, hemos iniciado un proyecto en CodePlex con un conjunto de clases envoltorio que pueden ayudarnos a la hora de realizar las pruebas con TypeMock y que está a un tris de quedarse obsoleto.

Antes de continuar me gustaría hacer una pequeña recapitulación sobre algunos puntos y características que nos ofrece TypeMock a la hora de realizar pruebas para SharePoint.

Veamos un sencillo ejemplo, para probar el código siguiente:

   1:  public Guid SampleGetSiteID()

   2:  {

   3:       Guid siteID = Guid.Empty;

   4:   

   5:       using(SPSite site = new SPSite("http://moss"))

   6:       {

   7:           siteID = site.ID;

   8:       }           

   9:   

  10:       return siteID;

  11:  }

   1:  [TestMethod]

   2:  public void SampleGetSiteID_ReflectiveMock()

   3:  {

   4:     MockManager.ClearAll();

   5:     MockManager.Init();

   6:   

   7:     Guid expectedId = Guid.NewGuid(); 

   8:   

   9:     Mock<SPSite> mockFutureInstanceOfSPSite = MockManager.Mock<SPSite>(Constructor.Mocked);

  10:     mockFutureInstanceOfSPSite.ExpectGetAlways("ID", expectedId);

  11:   

  12:     Samples target = new Samples();

  13:     Guid resultId = target.SampleGetSiteID();

  14:   

  15:     Assert.AreEqual(resultId, expectedId);

  16:  }

   1:  [TestMethod] 

   2:  public void SampleGetSiteID_NaturalMock()

   3:  {

   4:      MockManager.ClearAll();

   5:      MockManager.Init();

   6:   

   7:      Guid expectedId = Guid.NewGuid();

   8:   

   9:      using (RecordExpectations recorder = RecorderManager.StartRecording())

  10:      {

  11:          SPSite mockFutureInstanceOfSPSite = new SPSite(string.Empty);

  12:          recorder.ExpectAndReturn(mockFutureInstanceOfSPSite.ID, expectedId); 

  13:      }

  14:   

  15:      Samples target = new Samples();

  16:      Guid resultId = target.SampleGetSiteID();

  17:   

  18:      Assert.AreEqual(resultId, expectedId);

  19:  }

   1:  public int SampleGetWebsInSite(SPSite site)

   2:  {

   3:      int countWebsInSite;

   4:   

   5:      using (SPWeb web = site.OpenWeb())

   6:      {

   7:          countWebsInSite = web.Webs.Count;

   8:      }

   9:              

  10:      return countWebsInSite;

  11:  }  

   1:  [TestMethod]

   2:  public void SampleGetWebsInSite_Test_Reflective()

   3:  {

   4:      MockManager.ClearAll();

   5:      MockManager.Init();

   6:   

   7:      MockObject<SPSite> mockSPSite = MockManager.MockObject<SPSite>(Constructor.Mocked);

   8:      MockObject<SPWeb> mockSPWeb = MockManager.MockObject<SPWeb>(Constructor.Mocked);

   9:      MockObject<SPWebCollection> mockSPWebCollection = MockManager.MockObject<SPWebCollection>(Constructor.Mocked);

  10:   

  11:      SPWeb webInstance = mockSPWeb.MockedInstance;

  12:      SPWebCollection webCollectionInstance = mockSPWebCollection.MockedInstance;

  13:   

  14:      mockSPSite.ExpectAndReturn("OpenWeb", webInstance);

  15:      mockSPWeb.ExpectGet("Webs", webCollectionInstance);

  16:      mockSPWebCollection.ExpectGet("Count", 5);

  17:   

  18:      Samples target = new Samples();

  19:      int websInSite = target.SampleGetWebsInSite(mockSPSite.MockedInstance);

  20:   

  21:      Assert.AreEqual(websInSite, 5);

  22:      MockManager.Verify();

  23:  }

   1:  [TestMethod]

   2:  public void SampleGetWebsInSite_Test_NaturalMock()

   3:  {

   4:      MockManager.ClearAll();

   5:      MockManager.Init();

   6:   

   7:      SPWeb web = MockManager.MockObject<SPWeb>().MockedInstance;

   8:      SPWebCollection webs = MockManager.MockObject<SPWebCollection>().MockedInstance;

   9:   

  10:      using (RecordExpectations recorder = RecorderManager.StartRecording())

  11:      {

  12:          SPSite site = new SPSite("");

  13:   

  14:          recorder.ExpectAndReturn(site.OpenWeb(), web);

  15:          recorder.ExpectAndReturn(web.Webs, webs);

  16:          recorder.ExpectAndReturn(webs.Count, 5); 

  17:      }

  18:   

  19:      Samples target = new Samples();

  20:      int websInSite = target.SampleGetWebsInSite(new SPSite(""));

  21:   

  22:      Assert.AreEqual(websInSite, 5);

  23:      MockManager.Verify();

  24:  }