Esempi di sintassi di query Method-Based: operatori di aggregazione (LINQ to DataSet)

Negli esempi di questo argomento viene illustrato come usare gli operatori Aggregate, Average, Count, LongCount, Max, Mine Sum per eseguire query su un DataSet e aggregare i dati usando la sintassi della query del metodo.

Il metodo FillDataSet usato in questi esempi è specificato in Caricamento di dati in un dataset.

Gli esempi in questo argomento usano le tabelle Contact, Address, Product, SalesOrderHeader e SalesOrderDetail nel database di esempio AdventureWorks.

Gli esempi in questo argomento usano le istruzioni using/Imports seguenti:

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Globalization;
using System.Linq;
using System.Windows.Forms;

Per altre informazioni, vedere Procedura: Creare un progetto LINQ to DataSet in Visual Studio.

Aggregato

Esempio

In questo esempio viene utilizzato il metodo Aggregate per ottenere i primi 5 contatti dalla tabella Contact e creare un elenco delimitato da virgole dei nomi.

// Fill the DataSet.
DataSet ds = new DataSet();
ds.Locale = CultureInfo.InvariantCulture;
FillDataSet(ds);

IEnumerable<DataRow> contacts = ds.Tables["Contact"].AsEnumerable();

string nameList =
    contacts.Take(5).Select(contact => contact.Field<string>("LastName")).Aggregate((workingList, next) => workingList + "," + next);

Console.WriteLine(nameList);

Medio

Esempio

In questo esempio viene utilizzato il metodo Average per trovare il prezzo di listino medio dei prodotti.

// Fill the DataSet.
DataSet ds = new DataSet();
ds.Locale = CultureInfo.InvariantCulture;
FillDataSet(ds);

var products = ds.Tables["Product"].AsEnumerable();

Decimal averageListPrice =
    products.Average(product => product.Field<Decimal>("ListPrice"));

Console.WriteLine($"The average list price of all the products is ${averageListPrice}");

Esempio

In questo esempio viene utilizzato il metodo Average per trovare il prezzo di listino medio dei prodotti di ogni stile.

// Fill the DataSet.
DataSet ds = new DataSet();
ds.Locale = CultureInfo.InvariantCulture;
FillDataSet(ds);

var products = ds.Tables["Product"].AsEnumerable();

var query = from product in products
            group product by product.Field<string>("Style") into g
            select new
            {
                Style = g.Key,
                AverageListPrice =
                    g.Average(product => product.Field<Decimal>("ListPrice"))
            };

foreach (var product in query)
{
    Console.WriteLine($"Product style: {product.Style} Average list price: {product.AverageListPrice}");
}

Esempio

In questo esempio viene utilizzato il metodo Average per trovare il totale medio dovuto.

// Fill the DataSet.
DataSet ds = new DataSet();
ds.Locale = CultureInfo.InvariantCulture;
FillDataSet(ds);

DataTable orders = ds.Tables["SalesOrderHeader"];

Decimal averageTotalDue = orders.AsEnumerable().
    Average(order => order.Field<decimal>("TotalDue"));
Console.WriteLine($"The average TotalDue is {averageTotalDue}.");

Esempio

In questo esempio viene usato il metodo Average per ottenere il totale medio dovuto per ogni ID contatto.

// Fill the DataSet.
DataSet ds = new DataSet();
ds.Locale = CultureInfo.InvariantCulture;
FillDataSet(ds);

DataTable orders = ds.Tables["SalesOrderHeader"];

var query =
    from order in orders.AsEnumerable()
    group order by order.Field<Int32>("ContactID") into g
    select new
    {
        Category = g.Key,
        averageTotalDue =
            g.Average(order => order.Field<decimal>("TotalDue"))
    };

foreach (var order in query)
{
    Console.WriteLine($"ContactID = {order.Category} \t Average TotalDue = {order.averageTotalDue}");
}

Esempio

In questo esempio viene utilizzato il metodo Average per ottenere gli ordini con il TotalDue medio per ogni contatto.

// Fill the DataSet.
DataSet ds = new DataSet();
ds.Locale = CultureInfo.InvariantCulture;
FillDataSet(ds);

DataTable orders = ds.Tables["SalesOrderHeader"];

var query =
    from order in orders.AsEnumerable()
    group order by order.Field<Int32>("ContactID") into g
    let averageTotalDue = g.Average(order => order.Field<decimal>("TotalDue"))
    select new
    {
        Category = g.Key,
        CheapestProducts =
            g.Where(order => order.Field<decimal>("TotalDue") ==
                        averageTotalDue)
    };

foreach (var orderGroup in query)
{
    Console.WriteLine($"ContactID: {orderGroup.Category}");
    foreach (var order in orderGroup.CheapestProducts)
    {
        Console.WriteLine($"Average total due for SalesOrderID {order.Field<Int32>("SalesOrderID")} is: {order.Field<decimal>("TotalDue")}");
    }
    Console.WriteLine("");
}

Contare

Esempio

In questo esempio viene utilizzato il metodo Count per restituire il numero di prodotti nella tabella Product.

// Fill the DataSet.
DataSet ds = new DataSet();
ds.Locale = CultureInfo.InvariantCulture;
FillDataSet(ds);

var products = ds.Tables["Product"].AsEnumerable();

int numProducts = products.Count();

Console.WriteLine($"There are {numProducts} products.");

Esempio

In questo esempio viene utilizzato il metodo Count per restituire un elenco di ID contatto e il numero di ordini di ognuno.

// Fill the DataSet.
DataSet ds = new DataSet();
ds.Locale = CultureInfo.InvariantCulture;
FillDataSet(ds);

DataTable contacts = ds.Tables["Contact"];

var query = from contact in contacts.AsEnumerable()
            select new
            {
                CustomerID = contact.Field<int>("ContactID"),
                OrderCount =
                    contact.GetChildRows("SalesOrderContact").Count()
            };

foreach (var contact in query)
{
    Console.WriteLine($"CustomerID = {contact.CustomerID} \t OrderCount = {contact.OrderCount}");
}

Esempio

Questo esempio raggruppa i prodotti in base al colore e usa il metodo Count per restituire il numero di prodotti in ogni gruppo di colori.

// Fill the DataSet.
DataSet ds = new DataSet();
ds.Locale = CultureInfo.InvariantCulture;
FillDataSet(ds);

DataTable products = ds.Tables["Product"];

var query =
    from product in products.AsEnumerable()
    group product by product.Field<string>("Color") into g
    select new { Color = g.Key, ProductCount = g.Count() };

foreach (var product in query)
{
    Console.WriteLine($"Color = {product.Color} \t ProductCount = {product.ProductCount}");
}

LongCount

Esempio

Questo esempio ottiene il conteggio dei contatti come numero intero lungo.

// Fill the DataSet.
DataSet ds = new DataSet();
ds.Locale = CultureInfo.InvariantCulture;
FillDataSet(ds);

DataTable contacts = ds.Tables["Contact"];

long numberOfContacts = contacts.AsEnumerable().LongCount();
Console.WriteLine($"There are {numberOfContacts} Contacts");

Max

Esempio

In questo esempio viene utilizzato il metodo Max per ottenere il massimo totale dovuto.

// Fill the DataSet.
DataSet ds = new DataSet();
ds.Locale = CultureInfo.InvariantCulture;
FillDataSet(ds);

DataTable orders = ds.Tables["SalesOrderHeader"];

Decimal maxTotalDue = orders.AsEnumerable().
    Max(w => w.Field<decimal>("TotalDue"));
Console.WriteLine($"The maximum TotalDue is {maxTotalDue}.");

Esempio

In questo esempio viene usato il metodo Max per ottenere il totale massimo dovuto per ogni ID contatto.

// Fill the DataSet.
DataSet ds = new DataSet();
ds.Locale = CultureInfo.InvariantCulture;
FillDataSet(ds);

DataTable orders = ds.Tables["SalesOrderHeader"];

var query =
    from order in orders.AsEnumerable()
    group order by order.Field<Int32>("ContactID") into g
    select new
    {
        Category = g.Key,
        maxTotalDue =
            g.Max(order => order.Field<decimal>("TotalDue"))
    };

foreach (var order in query)
{
    Console.WriteLine($"ContactID = {order.Category} \t Maximum TotalDue = {order.maxTotalDue}");
}

Esempio

In questo esempio viene usato il metodo Max per ottenere gli ordini con il TotalDue più grande per ogni ID contatto.

// Fill the DataSet.
DataSet ds = new DataSet();
ds.Locale = CultureInfo.InvariantCulture;
FillDataSet(ds);

DataTable orders = ds.Tables["SalesOrderHeader"];

var query =
    from order in orders.AsEnumerable()
    group order by order.Field<Int32>("ContactID") into g
    let maxTotalDue = g.Max(order => order.Field<decimal>("TotalDue"))
    select new
    {
        Category = g.Key,
        CheapestProducts =
            g.Where(order => order.Field<decimal>("TotalDue") ==
                        maxTotalDue)
    };

foreach (var orderGroup in query)
{
    Console.WriteLine($"ContactID: {orderGroup.Category}");
    foreach (var order in orderGroup.CheapestProducts)
    {
        Console.WriteLine($"MaxTotalDue {order.Field<decimal>("TotalDue")} for SalesOrderID {order.Field<Int32>("SalesOrderID")}: ");
    }
}

Minuti

Esempio

In questo esempio viene usato il metodo Min per ottenere l'importo totale più basso dovuto.

// Fill the DataSet.
DataSet ds = new DataSet();
ds.Locale = CultureInfo.InvariantCulture;
FillDataSet(ds);

DataTable orders = ds.Tables["SalesOrderHeader"];

Decimal smallestTotalDue = orders.AsEnumerable().
    Min(totalDue => totalDue.Field<decimal>("TotalDue"));
Console.WriteLine($"The smallest TotalDue is {smallestTotalDue}.");

Esempio

In questo esempio viene usato il metodo Min per ottenere il totale minimo dovuto per ogni ID contatto.

// Fill the DataSet.
DataSet ds = new DataSet();
ds.Locale = CultureInfo.InvariantCulture;
FillDataSet(ds);

DataTable orders = ds.Tables["SalesOrderHeader"];

var query =
    from order in orders.AsEnumerable()
    group order by order.Field<Int32>("ContactID") into g
    select new
    {
        Category = g.Key,
        smallestTotalDue =
            g.Min(order => order.Field<decimal>("TotalDue"))
    };

foreach (var order in query)
{
    Console.WriteLine($"ContactID = {order.Category} \t Minimum TotalDue = {order.smallestTotalDue}");
}

Esempio

In questo esempio viene utilizzato il metodo Min per ottenere gli ordini con il totale più piccolo dovuto per ogni contatto.

// Fill the DataSet.
DataSet ds = new DataSet();
ds.Locale = CultureInfo.InvariantCulture;
FillDataSet(ds);

DataTable orders = ds.Tables["SalesOrderHeader"];

var query =
    from order in orders.AsEnumerable()
    group order by order.Field<Int32>("ContactID") into g
    let minTotalDue = g.Min(order => order.Field<decimal>("TotalDue"))
    select new
    {
        Category = g.Key,
        smallestTotalDue =
            g.Where(order => order.Field<decimal>("TotalDue") ==
                        minTotalDue)
    };

foreach (var orderGroup in query)
{
    Console.WriteLine($"ContactID: {orderGroup.Category}");
    foreach (var order in orderGroup.smallestTotalDue)
    {
        Console.WriteLine($"Minimum TotalDue {order.Field<decimal>("TotalDue")} for SalesOrderID {order.Field<Int32>("SalesOrderID")}: ");
    }
    Console.WriteLine("");
}

Somma

Esempio

In questo esempio viene utilizzato il metodo Sum per ottenere il numero totale di quantità di ordini nella tabella SalesOrderDetail.

// Fill the DataSet.
DataSet ds = new DataSet();
ds.Locale = CultureInfo.InvariantCulture;
FillDataSet(ds);

DataTable orders = ds.Tables["SalesOrderDetail"];

double totalOrderQty = orders.AsEnumerable().
    Sum(o => o.Field<Int16>("OrderQty"));
Console.WriteLine($"There are a total of {totalOrderQty} OrderQty.");

Esempio

In questo esempio viene usato il metodo Sum per ottenere il totale dovuto per ogni ID contatto.

// Fill the DataSet.
DataSet ds = new DataSet();
ds.Locale = CultureInfo.InvariantCulture;
FillDataSet(ds);

DataTable orders = ds.Tables["SalesOrderHeader"];

var query =
    from order in orders.AsEnumerable()
    group order by order.Field<Int32>("ContactID") into g
    select new
    {
        Category = g.Key,
        TotalDue = g.Sum(order => order.Field<decimal>("TotalDue")),
    };
foreach (var order in query)
{
    Console.WriteLine($"ContactID = {order.Category} \t TotalDue sum = {order.TotalDue}");
}

Vedere anche

• caricamento di dati in un set di dati
• Esempi di LINQ to DataSet
• Panoramica degli operatori di query standard (C#)
• Panoramica degli operatori di query standard (Visual Basic)