Estaba comprobando el performance de una aplicación con ANTS Profiler y me he dado cuenta que tienes que ir con mucho ojito cuando trabajas con los resultados de una sentencia LINQ, en el código que os pego reglaCol es el resultado de una sentencia LINQ a Objetos:

Podéis ver que se ejecuta dos veces, una vez cuando la uso en el foreach:

y otra cuando la copia a una Lista:

Hasta ahora yo creía que la segunda vez que accedías no se ejecutaba si no que tenia la información en algún cache, pero se ve que no, así que copiándola a la lista antes del foreach y usando la lista en el foreach hay una mejora importante de rendimiento sin hacer prácticamente nada.

Si esto no es así que alguien me corrija pls, porque me he quedado a cuadros …

Estaba escribiendo un POST sobre usar IEqualityComparer para eliminar los objetos repetidos de una colección sin demasiado código, pero no funciona !!!

Hemos estado probándolo en un código aquí en el trabajo y eso no va, o no hace lo que esperabamos

Al final la manera que hemos usando es usando un ExtensionMethod y una Método de comparación, siguiendo lo que hemos leído en este blog:
http://blog.jordanterrell.com/post/LINQ-Distinct()-does-not-work-as-expected.aspx

La idea es crear la extensión en una clase estática:

namespace MyNameSpace
{
    public static class  ExtensionMethods
    {
        public static IEnumerable<T> RemoveDuplicates<T>
             (this IEnumerable<T> source, Func<T, T, bool> equater)
        {
            List<T> result = new List<T>();

            foreach (T item in source)
            {
                if (result.All(t => !equater(item, t)))
                {
                    result.Add(item);
                }
            }

            return result;
        }

    }
}

Esto hará que este método se añada a las colecciones de clases que estén en el mismo espacio de nombres, luego solo hay que crear el método que usaremos para comparar las clases, en mi caso uno que mira si los campos son iguales:

public static bool MyClassEquals(MyClass rec1, MyClass rec2)
{
    Type t = rec1.GetType();
    FieldInfo[] fi = t.GetFields();

    for (int i = 0; i < fi.Length; i++)
    {
        if (fi[i].GetValue(rec1).ToString() !=
            fi[i].GetValue(rec2).ToString())
            return false;
    }

    return true;
}

Y ya estamos listos para usarlo

foreach (MyClass c in MyClassList.RemoveDuplicates(MyClassEquals))

Con LINQ 2 SQL y usando Take, es realmente sencillo obtener los últimos o los primeros registros de una Tabla, simplemente tenemos que ordenarla como nos interese con el order by y usar el método Take para indicar cuantos registros queremos.

Aquí dejo un ejemplo para coger los últimos registros de una tabla.

   public List<object> GetLastRecords(int NoOfRecords)
        {
            var records =
                (from r in DataClassesDataContext.Table
                 orderby r.Pk descending select r).Take(NoOfRecords);

            List<object> Result = new List<object>();

            foreach (Record record in records)
            {
                Result.Add(records);
            }

            return Result;
        }

El otro día estaba trabajando con unas clases que eran contenedoras de varios tipos de clases, en un array de Objetos, vi que estábamos accediendo al objeto por posición y luego haciéndole cast, suponiendo que ese tipo de objeto siempre estaría en esa posición, pero cuando se producían errores todos los objetos se movían hacia abajo al insertar un objeto Error.

¿Para que suelto este rollo? pues porque me puse a probar LINQ para buscar en colecciones por tipo de objeto y, desde luego, es la manera mas elegante, cada día estoy mas enamorado de LINQ.

Aquí os dejo un código de ejemplo:

 public static void Test()
        {
            List<object> Lista = new List<object>();

            Lista.Add(1);
            Lista.Add(2);
            Lista.Add(3);
            Lista.Add(4);

            Lista.Add("a");
            Lista.Add("b");
            Lista.Add("c");
            Lista.Add("d");

            Lista.Add(DateTime.Today);
            Lista.Add(DateTime.Today.AddDays(1));
            Lista.Add(DateTime.Today.AddDays(2));
            Lista.Add(DateTime.Today.AddDays(3));

            var IntList =  from i in Lista where i.GetType() == typeof (int) select i;

            var StringList = from s in Lista where s.GetType() == typeof(string) select s;

            var DateTimeList =
                from d in Lista where d.GetType() == typeof(DateTime) select d;

            Console.WriteLine("Hay {0} Integers",IntList.Count());
            Console.WriteLine("Hay {0} Strings", StringList.Count());
            Console.WriteLine("Hay {0} DateTimes", DateTimeList.Count());

            Console.ReadLine();
        }

Estamos súper liados con proyectos nuevos, de ultima hora y para anteayer, así que nos queda poco tiempo para escribir … pero hace mucho tiempo que tengo pendiente este POST, así que ..

Estoy empezando a usar linq to objects para trabajar con mis colecciones de objetos y la verdad es que es alucinante, se simplifica tanto el código, tenéis que probarlo, engancha …

Voy a dejar unos ejemplos de código que estoy usando en los proyectos en marcha.

Aquí tenia un método que tenia que buscar en mi colección por unos valores y si no encontraba esos valores buscar por el mas cercano superior, eso en LINQ se queda en esta línea:

var t = from t1 in Lista
where
1.CodigoHabitacionLineaTarifaCliente == CodHabitacion
&&
t1.CodigoRegimenLineaTarifaCliente == CodigoRegimen
&&
t1.CodigoTarifaLineaTarifaCliene == CodigoTarifa
&&
t1.AdultosLineaTarifaCliente >= AD
&&
t1.NinosLineaTarifaCliente >= CH
&&
t1.CunasLineaTarifaCliente >= EN
orderby
t1.AdultosLineaTarifaCliente,
t1.NinosLineaTarifaCliente,
t1.CunasLineaTarifaCliente ascending
select t1;

Aquí una búsqueda normal de toda la vida

var t = from t1 in Lista
where
t1.CodigoHabitacionLineaTarifaCliente == CodHabitacion
&&
t1.CodigoRegimenLineaTarifaCliente == CodigoRegimen
&&
t1.CodigoTarifaLineaTarifaCliene == CodigoTarifa
select t1;
if (t.Count() == 0)
  throw new Exception(NDatos);

Y lo mejor, usar sum y group by en nuestras colecciones,

aqui agrupando y sumando precios x día

var GroupedPrices = from pd in b.PriceDetails group pd by pd.Day into g
select new {Day = g.Key, TotalPriceDay = g.Sum(v1 => v1.Amount)};

Cuando empeceis a usarlo no podreis vivir sin el

Los tipos anónimos son una de las grandes mejoras en C# 3.0, nos permiten definir tipos en el código sin hacer la definición "formal" de la clase mediante la palabra clave "var".

var MyVar = new
     {
         ID = 1,
         Name = "MyVar",
     };

Estos tipos nos serán realmente útiles en las sentencias LINQ

Bart De Smet ha creado un video de 20 minutos "Essential LINQ to Objects", en el nos explica los aspectos básicos para crear una implementación personalizada de los operadores estandar de consultas

LINQPad es una utilidad gratuita que nos permite ejecutar sentencias LINQ sobre bases de datos SQL Server

El aspecto es bastante parecido al SQL Management Studio, y la instalación es realmente sencilla, un exe y listo.

Es una herramienta que nos será de gran utilidad para testear nuestras consultas LINQ, soporta C#, VB y T-SQL y viene con multitud de ejemplos de consultas.

Tenemos disponible en MSDN 101 ejemplos de LINQ

La verdad es que están súper bien organizados agrupados por Operaciones, cada ejemplo con su código, pégale un vistazo.