OPTIMISATION DE LA SERIALISATION JSON POUR LES LIST<T>

using System;
using System.Data;
using System.Configuration;
using System.Linq;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Xml.Linq;
using System.Runtime.Serialization;
using System.Collections.Generic;
using System.Reflection;

/// <summary>
/// Permet d'optimiser la serailisation JSON d'une List&lt;T&gt;
/// </summary>
/// <typeparam name="T"></typeparam>
[DataContract]
public class JsonList<T>
{

    #region Constructors

    private static IEnumerable<String> _columns;
    private static IEnumerable<PropertyInfo> _properties;

    /// <summary>
    /// Ce constructeur sera appelé lors de la premiere utilisation du type "finale" => pour chaque T
    /// </summary>
    static JsonList()
    {
        // mis en cache de la liste des colonne en fonction du type T
        // TODO : Je ne prend pas en compte toutes les options du DataMemberAttribute, il y a donc des bugs si on joue avec des cas spécifique
        _properties = (from property in typeof(T).GetProperties()
                       let dataMemberAttributes = (DataMemberAttribute[])property.GetCustomAttributes(typeof(DataMemberAttribute), false)
                       where dataMemberAttributes.Length > 0
                       select property
                   ).ToList(); // ToList pour pas garder le IEnumerable et donc refaire la requête à chaque fois

        _columns = (from property in _properties
                    // on pourrait mettre la recherche de l'attribut en cache à partir de la requete précedente, 
                    // mais cela nécessite de créer une structure rien que pour ca ...
                    let dataMemberAttribute = ((DataMemberAttribute[])property.GetCustomAttributes(typeof(DataMemberAttribute), false))[0]
                    select !String.IsNullOrEmpty(dataMemberAttribute.Name) ? dataMemberAttribute.Name : property.Name
                   ).ToList(); // ToList pour pas garder le IEnumerable et donc refaire la requête à chaque fois
    }

    private IEnumerable<T> _innerList;

    public JsonList(IEnumerable<T> innerList)
    {
        this._innerList = innerList;
    }

    #endregion

    #region implicit casting operator

    public static implicit operator JsonList<T>(List<T> items)
    {
        return new JsonList<T>(items);
    }
    public static implicit operator JsonList<T>(T[] items)
    {
        return new JsonList<T>(items);
    }

    #endregion

    #region Properties

    /// <summary>
    /// Contient un tableau contenant le nom des différents colonnes
    /// </summary>
    [DataMember]
    public IEnumerable<String> Columns
    {
        get { return _columns; }
        set { throw new NotSupportedException("Deserialization of this object is not supporter yet"); }
    }

    /// <summary>
    /// Contient un tableau de tableau contenant les valeurs de la list 
    /// </summary>
    /// <remarks>
    /// [
    ///   ['FirstName1', 'LastName1'],
    ///   ['FirstName2', 'LastName2']
    /// ]
    /// </remarks>
    [DataMember]
    public IEnumerable<IEnumerable<Object>> Values
    {
        get
        {
            // TODO : optimiser ca en utilisant les Expression de C#3 afin de mettre en cache le getter
            return from item in this._innerList
                   select from property in _properties
                          select property.GetValue(item, null);
        }
        set { throw new NotSupportedException("Deserialization of this object is not supporter yet"); }
    }

    #endregion
}