Clausola group (Riferimento C#)group clause (C# Reference)

La clausola group restituisce una sequenza di oggetti IGrouping<TKey,TElement> che contengono zero o più elementi corrispondenti al valore chiave per il gruppo.The group clause returns a sequence of IGrouping<TKey,TElement> objects that contain zero or more items that match the key value for the group. Ad esempio, è possibile raggruppare una sequenza di stringhe in base alla prima lettera di ogni stringa.For example, you can group a sequence of strings according to the first letter in each string. In questo caso, la prima lettera è la chiave con tipo char e viene archiviata nella proprietà Key di ogni oggetto IGrouping<TKey,TElement>.In this case, the first letter is the key and has a type char, and is stored in the Key property of each IGrouping<TKey,TElement> object. Il compilatore deduce automaticamente il tipo della chiave.The compiler infers the type of the key.

È possibile terminare un'espressione di query con una clausola group, come illustrato nell'esempio seguente:You can end a query expression with a group clause, as shown in the following example:

// Query variable is an IEnumerable<IGrouping<char, Student>>
var studentQuery1 =
    from student in students
    group student by student.Last[0];

Per eseguire operazioni di query aggiuntive per ogni gruppo, è possibile specificare un identificatore temporaneo usando la parola chiave contestuale into.If you want to perform additional query operations on each group, you can specify a temporary identifier by using the into contextual keyword. Quando si usa into, è necessario continuare a eseguire la query ed eventualmente terminarla con un'istruzione select o un'altra clausola group, come illustrato nel seguente estratto di codice:When you use into, you must continue with the query, and eventually end it with either a select statement or another group clause, as shown in the following excerpt:

// Group students by the first letter of their last name
// Query variable is an IEnumerable<IGrouping<char, Student>>
var studentQuery2 =
    from student in students
    group student by student.Last[0] into g
    orderby g.Key
    select g;

Esempi di utilizzo di più completi di group con e senza into sono disponibili nella sezione Esempio di questo articolo.More complete examples of the use of group with and without into are provided in the Example section of this article.

Enumerazione dei risultati di una query con raggruppamentoEnumerating the results of a group query

Poiché gli oggetti IGrouping<TKey,TElement> prodotti da una query group sono essenzialmente un elenco di elenchi, è necessario usare un ciclo foreach nidificato per accedere agli elementi di ogni gruppo.Because the IGrouping<TKey,TElement> objects produced by a group query are essentially a list of lists, you must use a nested foreach loop to access the items in each group. Il ciclo esterno esegue l'iterazione delle chiavi del gruppo e il ciclo interno esegue l'iterazione di ogni voce nel gruppo.The outer loop iterates over the group keys, and the inner loop iterates over each item in the group itself. Un gruppo può avere una chiave ma non elementi.A group may have a key but no elements. Di seguito è riportato il ciclo foreach che esegue la query negli esempi di codice precedenti:The following is the foreach loop that executes the query in the previous code examples:

// Iterate group items with a nested foreach. This IGrouping encapsulates
// a sequence of Student objects, and a Key of type char.
// For convenience, var can also be used in the foreach statement.
foreach (IGrouping<char, Student> studentGroup in studentQuery2)
{
     Console.WriteLine(studentGroup.Key);
     // Explicit type for student could also be used here.
     foreach (var student in studentGroup)
     {
         Console.WriteLine("   {0}, {1}", student.Last, student.First);
     }
 }

Tipi di chiaveKey types

Le chiavi di raggruppamento possono essere di qualsiasi tipo, ad esempio una stringa, un tipo numerico incorporato, un tipo con nome definito dall'utente o un tipo anonimo.Group keys can be any type, such as a string, a built-in numeric type, or a user-defined named type or anonymous type.

Raggruppamento per stringaGrouping by string

Negli esempi di codice precedenti è stato usato un oggetto char.The previous code examples used a char. Si potrebbe specificare in alternativa una chiave di stringa, ad esempio il cognome completo:A string key could easily have been specified instead, for example the complete last name:

// Same as previous example except we use the entire last name as a key.
// Query variable is an IEnumerable<IGrouping<string, Student>>
var studentQuery3 =
    from student in students
    group student by student.Last;

Raggruppamento per valore booleanoGrouping by bool

L'esempio seguente illustra l'uso di un valore booleano per una chiave in modo da dividere i risultati in due gruppi.The following example shows the use of a bool value for a key to divide the results into two groups. Si noti che il valore è generato da una sottoespressione nella clausola group.Note that the value is produced by a sub-expression in the group clause.

class GroupSample1
{
    // The element type of the data source.
    public class Student
    {
        public string First { get; set; }
        public string Last { get; set; }
        public int ID { get; set; }
        public List<int> Scores;
    }

    public static List<Student> GetStudents()
    {
        // Use a collection initializer to create the data source. Note that each element
        //  in the list contains an inner sequence of scores.
        List<Student> students = new List<Student>
        {
           new Student {First="Svetlana", Last="Omelchenko", ID=111, Scores= new List<int> {97, 72, 81, 60}},
           new Student {First="Claire", Last="O'Donnell", ID=112, Scores= new List<int> {75, 84, 91, 39}},
           new Student {First="Sven", Last="Mortensen", ID=113, Scores= new List<int> {99, 89, 91, 95}},
           new Student {First="Cesar", Last="Garcia", ID=114, Scores= new List<int> {72, 81, 65, 84}},
           new Student {First="Debra", Last="Garcia", ID=115, Scores= new List<int> {97, 89, 85, 82}}
        };

        return students;
    }

    static void Main()
    {
        // Obtain the data source.
        List<Student> students = GetStudents();

        // Group by true or false.
        // Query variable is an IEnumerable<IGrouping<bool, Student>>
        var booleanGroupQuery =
            from student in students
            group student by student.Scores.Average() >= 80; //pass or fail!

        // Execute the query and access items in each group
        foreach (var studentGroup in booleanGroupQuery)
        {
            Console.WriteLine(studentGroup.Key == true ? "High averages" : "Low averages");
            foreach (var student in studentGroup)
            {
                Console.WriteLine("   {0}, {1}:{2}", student.Last, student.First, student.Scores.Average());
            }
        }

        // Keep the console window open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
/* Output:
  Low averages
   Omelchenko, Svetlana:77.5
   O'Donnell, Claire:72.25
   Garcia, Cesar:75.5
  High averages
   Mortensen, Sven:93.5
   Garcia, Debra:88.25
*/

Raggruppamento per intervallo numericoGrouping by numeric range

Nell'esempio seguente viene usata un'espressione per creare le chiavi di raggruppamento numeriche che rappresentano un intervallo percentile.The next example uses an expression to create numeric group keys that represent a percentile range. Si noti l'uso di let come comoda posizione di archiviazione del risultato della chiamata a un metodo, in modo da non dover chiamare il metodo due volte nella clausola group.Note the use of let as a convenient location to store a method call result, so that you don't have to call the method two times in the group clause. Per altre informazioni su come usare in modo sicuro i metodi nelle espressioni di query, vedere gestire le eccezioni nelle espressioni di query.For more information about how to safely use methods in query expressions, see Handle exceptions in query expressions.

class GroupSample2
{
    // The element type of the data source.
    public class Student
    {
        public string First { get; set; }
        public string Last { get; set; }
        public int ID { get; set; }
        public List<int> Scores;
    }

    public static List<Student> GetStudents()
    {
        // Use a collection initializer to create the data source. Note that each element
        //  in the list contains an inner sequence of scores.
        List<Student> students = new List<Student>
        {
           new Student {First="Svetlana", Last="Omelchenko", ID=111, Scores= new List<int> {97, 72, 81, 60}},
           new Student {First="Claire", Last="O'Donnell", ID=112, Scores= new List<int> {75, 84, 91, 39}},
           new Student {First="Sven", Last="Mortensen", ID=113, Scores= new List<int> {99, 89, 91, 95}},
           new Student {First="Cesar", Last="Garcia", ID=114, Scores= new List<int> {72, 81, 65, 84}},
           new Student {First="Debra", Last="Garcia", ID=115, Scores= new List<int> {97, 89, 85, 82}}
        };

        return students;
    }

    // This method groups students into percentile ranges based on their
    // grade average. The Average method returns a double, so to produce a whole
    // number it is necessary to cast to int before dividing by 10.
    static void Main()
    {
        // Obtain the data source.
        List<Student> students = GetStudents();

        // Write the query.
        var studentQuery =
            from student in students
            let avg = (int)student.Scores.Average()
            group student by (avg / 10) into g
            orderby g.Key
            select g;

        // Execute the query.
        foreach (var studentGroup in studentQuery)
        {
            int temp = studentGroup.Key * 10;
            Console.WriteLine("Students with an average between {0} and {1}", temp, temp + 10);
            foreach (var student in studentGroup)
            {
                Console.WriteLine("   {0}, {1}:{2}", student.Last, student.First, student.Scores.Average());
            }
        }

        // Keep the console window open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
/* Output:
     Students with an average between 70 and 80
       Omelchenko, Svetlana:77.5
       O'Donnell, Claire:72.25
       Garcia, Cesar:75.5
     Students with an average between 80 and 90
       Garcia, Debra:88.25
     Students with an average between 90 and 100
       Mortensen, Sven:93.5
 */

Raggruppamento per chiavi composteGrouping by composite keys

Usare una chiave composta se si vuole raggruppare gli elementi in base a più di una chiave.Use a composite key when you want to group elements according to more than one key. Per creare una chiave composta, usare un tipo anonimo o un tipo denominato per contenere l'elemento key.You create a composite key by using an anonymous type or a named type to hold the key element. Nell'esempio seguente si suppone che una classe Person sia stata dichiarata con i membri denominati surname e city.In the following example, assume that a class Person has been declared with members named surname and city. La clausola group determina la creazione di un gruppo separato per ogni insieme di persone con lo stesso cognome e la stessa città.The group clause causes a separate group to be created for each set of persons with the same last name and the same city.

group person by new {name = person.surname, city = person.city};

Usare un tipo denominato se è necessario passare la variabile di query a un altro metodo.Use a named type if you must pass the query variable to another method. Creare una classe speciale usando proprietà implementate automaticamente per le chiavi e quindi eseguire l'override dei metodi Equals e GetHashCode.Create a special class using auto-implemented properties for the keys, and then override the Equals and GetHashCode methods. È anche possibile usare uno struct e in questo caso non è strettamente necessario eseguire l'override dei metodi.You can also use a struct, in which case you do not strictly have to override those methods. Per ulteriori informazioni, vedere come implementare una classe Lightweight con proprietà implementate automaticamente e come eseguire una query per i file duplicati in un albero di directory.For more information see How to implement a lightweight class with auto-implemented properties and How to query for duplicate files in a directory tree. Il secondo articolo contiene un esempio di codice che illustra come usare una chiave composta con un tipo denominato.The latter article has a code example that demonstrates how to use a composite key with a named type.

EsempioExample

Nell'esempio seguente viene illustrato il modello standard per l'ordinamento dei dati di origine nei gruppi quando non viene applicata una logica di query aggiuntiva ai gruppi.The following example shows the standard pattern for ordering source data into groups when no additional query logic is applied to the groups. L'operazione è definita raggruppamento senza continuazione.This is called a grouping without a continuation. Gli elementi in una matrice di stringhe vengono raggruppati in base alla prima lettera.The elements in an array of strings are grouped according to their first letter. Il risultato della query è un tipo IGrouping<TKey,TElement> che contiene una proprietà pubblica Key di tipo char e una raccolta IEnumerable<T> che contiene ogni elemento nel raggruppamento.The result of the query is an IGrouping<TKey,TElement> type that contains a public Key property of type char and an IEnumerable<T> collection that contains each item in the grouping.

Il risultato di una clausola group è una sequenza di sequenze.The result of a group clause is a sequence of sequences. Di conseguenza, per accedere ai singoli elementi all'interno di ogni gruppo restituito, usare un ciclo foreach nidificato all'interno del ciclo che esegue l'iterazione delle chiavi di raggruppamento, come illustrato nell'esempio seguente.Therefore, to access the individual elements within each returned group, use a nested foreach loop inside the loop that iterates the group keys, as shown in the following example.

class GroupExample1
{
    static void Main()
    {
        // Create a data source.
        string[] words = { "blueberry", "chimpanzee", "abacus", "banana", "apple", "cheese" };

        // Create the query.
        var wordGroups =
            from w in words
            group w by w[0];

        // Execute the query.
        foreach (var wordGroup in wordGroups)
        {
            Console.WriteLine("Words that start with the letter '{0}':", wordGroup.Key);
            foreach (var word in wordGroup)
            {
                Console.WriteLine(word);
            }
        }

        // Keep the console window open in debug mode
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
/* Output:
      Words that start with the letter 'b':
        blueberry
        banana
      Words that start with the letter 'c':
        chimpanzee
        cheese
      Words that start with the letter 'a':
        abacus
        apple
     */

EsempioExample

In questo esempio viene illustrato come eseguire la logica aggiuntiva per i gruppi dopo che sono stati creati, usando una continuazione con into.This example shows how to perform additional logic on the groups after you have created them, by using a continuation with into. Per altre informazioni, vedere into.For more information, see into. Nell'esempio seguente viene eseguita una query di ogni gruppo per selezionare solo quelli il cui valore della chiave è una vocale.The following example queries each group to select only those whose key value is a vowel.

class GroupClauseExample2
{
    static void Main()
    {
        // Create the data source.
        string[] words2 = { "blueberry", "chimpanzee", "abacus", "banana", "apple", "cheese", "elephant", "umbrella", "anteater" };

        // Create the query.
        var wordGroups2 =
            from w in words2
            group w by w[0] into grps
            where (grps.Key == 'a' || grps.Key == 'e' || grps.Key == 'i'
                   || grps.Key == 'o' || grps.Key == 'u')
            select grps;

        // Execute the query.
        foreach (var wordGroup in wordGroups2)
        {
            Console.WriteLine("Groups that start with a vowel: {0}", wordGroup.Key);
            foreach (var word in wordGroup)
            {
                Console.WriteLine("   {0}", word);
            }
        }

        // Keep the console window open in debug mode
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
/* Output:
    Groups that start with a vowel: a
        abacus
        apple
        anteater
    Groups that start with a vowel: e
        elephant
    Groups that start with a vowel: u
        umbrella
*/

OsservazioniRemarks

In fase di compilazione le clausole group vengono convertite in chiamate al metodo GroupBy.At compile time, group clauses are translated into calls to the GroupBy method.

Vedere ancheSee also