[Linq] DataSet – Agrupar y totalizar

 

Introducción

---

En este articulo analizaremos como trabajar con los datos procedentes de un datatable, realizando operaciones por medio de la ayuda de linq, y luego confeccionado un datatable distinto, cuya estructura de campos difiere de la original.

Para esta operación se contara con un datatable con documento de clientes, y un campo total que informa cuantos de estos se tienen registrados.

La idea es obtener en otro datatable la cantidad total agrupando todos los clientes.

 

Agrupar con Linq

---

Para esta operación se realizaría una agrupación mediante la funcionalidad que provee linq.

private void button1_Click(object sender, EventArgs e)
{
    IEnumerable<IGrouping<string, DataRow>> query = from item in Datos().AsEnumerable()
                                                    group item by item["Documento"].ToString() into g
                                                    select g;


    DataTable resultado = Transformar(query);

    dataGridView1.AutoGenerateColumns = true;
    dataGridView1.DataSource = resultado;

}

Como se observa en la query de linq se agrupa por medio del campo “Documento”, y el resultado de esta operación se alojo en “g”, valor que es devuelto en la consulta.

Si bien podría haberse igualado toda la consulta a una variable definida como “var”, esto hubiera imposibilitado el pasaje de la información a un método de transformación, para la creación del nuevo datatable, es por eso que se crea el IEnumerable<>, que contiene el IGrouping<> también genérico.

 

Creación del nuevo DataTable

---

En esta operación en una primera implementación es algo manual, ya que toma el resultado de la consulta linq e itera para cargar el nuevo datatable, y en su camino realiza las operaciones de calculo.

private DataTable Transformar(IEnumerable<IGrouping<string, DataRow>> datos)
{
    //
    // Se define la estructura del DataTable
    //
    DataTable dt = new DataTable();
    dt.Columns.Add("Documento");
    dt.Columns.Add("CantRegistros");
    dt.Columns.Add("Total");

    //
    // Se recorre cada valor agruparo por linq y se vuelca el resultado 
    // en un nuevo registro del datatable
    //
    foreach (IGrouping<string, DataRow> item in datos)
    {
        DataRow row2 = dt.NewRow();
        row2["Documento"] = item.Key;
        row2["CantRegistros"] = item.Count();
        row2["Total"] = item.Sum<DataRow>(x => Convert.ToInt32(x["Total"]));

        dt.Rows.Add(row2);
    }

    return dt;
}

Debe observarse como se trabaja con los métodos extendidos, y en ellos se aplica la funcionalidad Lambda, puntualmente al indica que campo debe sumarse.

 

[C#]

 

Creación del DataTable con CopyToDataTable()

---

Una alternativa algo mejor a la transformación de datos podrías ser por medio del uso del método de extensión CopyToDataTable()

DataTableExtensions.CopyToDataTable<(Of <(T>)>)

Hay que remarcar un punto con este método, ya que de forma estándar solo permite convertir a DataTable aquellas consulta linq que devuelvan como resultado una DataRow.

Pero en nuestro ejemplo planteado esto es diferente ya que el datatable a devolver requiere de una transformación de los registro con respecto a los datos originales.

Pero esta situación esta contemplada, ya que es posible implementar un método CopyToDataTable<> genérico, en donde a base de un tipo de dato se arme un datatable.

Para esta implementación, se hará uso de la explicación proporcionada por siguiente articulo:

Cómo implementar CopyToDataTable<T> donde el tipo genérico T no es un objeto DataRow

El código del link de msdn, se ha volcado al archivo de nombre “CopytoDataTable.cs”, se podrá observar en el código de ejemplo adjunto en el articulo.

La implementación de la funcionalidad quedo reducida al siguiente código:

private void button1_Click(object sender, EventArgs e)
{

    var query = from item in Datos().AsEnumerable()
                group item by item["Documento"].ToString() into g
                select new DocumentoResult
                {
                    Documento = g.Key,
                    CantRegistros = g.Count(),
                    Total = g.Sum(x => Convert.ToInt32(x["Total"]))
                };


    DataTable resultado = query.CopyToDataTable<DocumentoResult>();

    dataGridView1.AutoGenerateColumns = true;
    dataGridView1.DataSource = resultado;

}

Esta nueva alternativa ya no necesita iterar por cada registro que dio como resultado la consulta linq, es mas se puede hacer uso del “var”, puesto que no es necesario pasar por parámetro la consulta para trabajarla.

Pero si se necesito de un pequeño cambio, en donde se ha definido una clase, de nombre “DocumentoResult”, la cual define los campos del nuevo DataTable.

public class DocumentoResult
{
    public string Documento { get; set; }
    public int CantRegistros { get; set; }
    public int Total { get; set; }

}

Siendo esta la clase usada en la definición del método genérico CopyToDataTable<>, cuando se usa en la línea:

DataTable resultado = query.CopyToDataTable<DocumentoResult>();

 

[C#]