linq - c# Agrupar una lista anidada secuencialmente

Estoy generando un yaml de la siguiente manera en c#:

- type: DEFAULT
  primitives:
  - sequenceNo: 1
    from: Environment
    to: uC
    event: register
- type: DEFAULT
  primitives:
  - sequenceNo: 4
    from: uP
    event: start cells
- type: LOOP
  primitives:
  - sequenceNo: 5
    from: uC
    to: uP
    event: keepAlive Question
- type: LOOP
  primitives:
  - sequenceNo: 6
    from: uP
    to: uC
    event: keepAlive Response
- type: DEFAULT
  primitives:
  - sequenceNo: 10
    from: uC
    to: uP
    event: switch off uP

Las siguientes son mis clases:

public class Type
{
    public string type { get; set; }
    public List<Primitive> primitives { get; set; }
}

public class Primitive
{
    [YamlIgnore]
    public int sequenceNo { get; set; }
    [YamlIgnore]
    public int startX { get; set; }
    [YamlIgnore]
    public int startY { get; set; }
    public string from { get; set; }
    public string to { get; set; }
    [YamlMember(Alias = "event")]
    public string events { get; set; }
    public string expectedState { get; set; }
}

Quiero agrupar la lista de la siguiente manera:

- type: DEFAULT
  primitives:
    - from: environment
      to: uC
      event: register
    - from: uP
      event: start cells
- type: LOOP
  primitives:
    - from: uC
      to: uP
      event: keepAlive Question
    - from: uP
      to: uC
      event: keepAlive Response
- type: DEFAULT
  primitives:
    from: uC
    to: uP
    event: switch off uP

Eso significa que quiero agruparlos secuencialmente según el tipo. Si puedo encontrar el mismo grupo, por ejemplo, DEFAULT uno tras otro, tengo que agrupar las primitivas de 2 DEFAULT secuenciales dentro de un DEFAULT y así sucesivamente. ¿Cómo puedo lograr eso? Hasta ahora he intentado usar un diccionario como el siguiente:

var res = types.GroupBy(r => r.type)
                  .ToDictionary(t => t.Key, t => t.Select(r => r.primitives).ToList());

Pero no obtengo la lista de forma secuencial.

------------------------------------

Siempre que tenga una secuencia de elementos similares y desee crear grupos de elementos que tenganalgo en común, considere usar una de las sobrecargas de GroupBy.

Quiere crear grupos de primitivas que tengan el mismo valor para el tipo de propiedad. Mi consejo sería utilizar la sobrecarga de GroupBy que tiene un parámetro resultSelector.

(para evitar malentendidos entre el tipo de clase y el tipo de propiedad, uso originalType para identificar un elemento de su colección original de tipos)

Primero haré grupos de tipos originales que tengan el mismo valor de propiedad Tipo. Luego, de la secuencia de elementos de este grupo (que son tipos originales), tome sus primitivas y aplánelas (SelectMany). A partir de aquí, seleccione las propiedades que desee.

// make groups of Types that have same value of property Type:
IEnumerable<Type> originalTypes = ...
var result = originalTypes.GroupBy(originalType => originalType.Type,

// parameter resultSelector: from every Type, and all original types that have this
// value of property Type, make one new:
(type, originalTypesThatHaveThisValueForType) => new
{
    Type = type,

    // to get all primitives, use SelectMany to flatten the elements in this group
    Primitives = originalTypesThatHaveThisValueForType
        .SelectMany(originalType => originalType.Primitives,

        (originalType, primitive) => new
        {
            From = primitive.From,
            To = primitive.To,
            ...
        })
        .ToList(),
});

En palabras: a partir de su secuencia original de Tipos, cree grupos de Tipos que tengan el mismo valor para la propiedad Tipo.

De cada grupo que haya creado, cree un objeto con dos propiedades: Tipo y Primitivas. El valor del tipo de propiedad es fácil: es el valor común de todos los tipos originales del grupo.

Para crear primitivas de propiedad, aplanamos cada elemento del grupo. Recuerde: el grupo es un grupo de "Tipos con sus Primitivos" (= tipo original). Usamos SelectMany para aplanar esto en combinaciones de [tipo original, primitivo].

Entonces, si el Tipo A original tiene las primitivas 1, 2, 3; y el tipo B original tiene las primitivas 6, 7, obtenemos las combinaciones:

[A, primitiva 1] [A, primitiva 2] [A, primitiva 3] [B, primitiva 6] [B, primitiva 7]

Ya no usaremos nada de A y B, ya usamos su valor común para el tipo de propiedad. Pero nos interesan las primitivas:de cada primitivo en las combinaciones formamos un objeto:

// from every combination, make one new object:
(originalType, primitive) => new {...}

1

Consulte la siguiente publicación para obtener mi respuesta. La versión del código que proporcionó se agrupa por tipo, pero quiero usar el grupo por claves contagiosas.

- Priom Biswas

30 de marzo de 2021 a las 8:33

------------------------------------

Se puede utilizar el siguiente método de extensión para agrupar por claves contagiosas:

public static class MyExtensions
{
    public static IEnumerable<IGrouping<TKey, TSource>> ChunkBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
    {
        return source.ChunkBy(keySelector, EqualityComparer<TKey>.Default);
    }

    public static IEnumerable<IGrouping<TKey, TSource>> ChunkBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
    {
        // Flag to signal end of source sequence.
        const bool noMoreSourceElements = true;

        // Auto-generated iterator for the source array.
        var enumerator = source.GetEnumerator();

        // Move to the first element in the source sequence.
        if (!enumerator.MoveNext()) yield break;

        // Iterate through source sequence and create a copy of each Chunk.
        // On each pass, the iterator advances to the first element of the next "Chunk"
        // in the source sequence. This loop corresponds to the outer foreach loop that
        // executes the query.
        Chunk<TKey, TSource> current = null;
        while (true)
        {
            // Get the key for the current Chunk. The source iterator will churn through
            // the source sequence until it finds an element with a key that doesn't match.
            var key = keySelector(enumerator.Current);

            // Make a new Chunk (group) object that initially has one GroupItem, which is a copy of the current source element.
            current = new Chunk<TKey, TSource>(key, enumerator, value => comparer.Equals(key, keySelector(value)));

            // Return the Chunk. A Chunk is an IGrouping<TKey,TSource>, which is the return value of the ChunkBy method.
            // At this point the Chunk only has the first element in its source sequence. The remaining elements will be
            // returned only when the client code foreach's over this chunk. See Chunk.GetEnumerator for more info.
            yield return current;

            // Check to see whether (a) the chunk has made a copy of all its source elements or
            // (b) the iterator has reached the end of the source sequence. If the caller uses an inner
            // foreach loop to iterate the chunk items, and that loop ran to completion,
            // then the Chunk.GetEnumerator method will already have made
            // copies of all chunk items before we get here. If the Chunk.GetEnumerator loop did not
            // enumerate all elements in the chunk, we need to do it here to avoid corrupting the iterator
            // for clients that may be calling us on a separate thread.
            if (current.CopyAllChunkElements() == noMoreSourceElements)
            {
                yield break;
            }
        }
    }

    // A Chunk is a contiguous group of one or more source elements that have the same key. A Chunk
    // has a key and a list of ChunkItem objects, which are copies of the elements in the source sequence.
    class Chunk<TKey, TSource> : IGrouping<TKey, TSource>
    {
        // INVARIANT: DoneCopyingChunk == true ||
        //   (predicate != null && predicate(enumerator.Current) && current.Value == enumerator.Current)

        // A Chunk has a linked list of ChunkItems, which represent the elements in the current chunk. Each ChunkItem
        // has a reference to the next ChunkItem in the list.
        class ChunkItem
        {
            public ChunkItem(TSource value)
            {
                Value = value;
            }
            public readonly TSource Value;
            public ChunkItem Next = null;
        }

        // The value that is used to determine matching elements
        private readonly TKey key;

        // Stores a reference to the enumerator for the source sequence
        private IEnumerator<TSource> enumerator;

        // A reference to the predicate that is used to compare keys.
        private Func<TSource, bool> predicate;

        // Stores the contents of the first source element that
        // belongs with this chunk.
        private readonly ChunkItem head;

        // End of the list. It is repositioned each time a new
        // ChunkItem is added.
        private ChunkItem tail;

        // Flag to indicate the source iterator has reached the end of the source sequence.
        internal bool isLastSourceElement = false;

        // Private object for thread syncronization
        private object m_Lock;

        // REQUIRES: enumerator != null && predicate != null
        public Chunk(TKey key, IEnumerator<TSource> enumerator, Func<TSource, bool> predicate)
        {
            this.key = key;
            this.enumerator = enumerator;
            this.predicate = predicate;

            // A Chunk always contains at least one element.
            head = new ChunkItem(enumerator.Current);

            // The end and beginning are the same until the list contains > 1 elements.
            tail = head;

            m_Lock = new object();
        }

        // Indicates that all chunk elements have been copied to the list of ChunkItems,
        // and the source enumerator is either at the end, or else on an element with a new key.
        // the tail of the linked list is set to null in the CopyNextChunkElement method if the
        // key of the next element does not match the current chunk's key, or there are no more elements in the source.
        private bool DoneCopyingChunk => tail == null;

        // Adds one ChunkItem to the current group
        // REQUIRES: !DoneCopyingChunk && lock(this)
        private void CopyNextChunkElement()
        {
            // Try to advance the iterator on the source sequence.
            // If MoveNext returns false we are at the end, and isLastSourceElement is set to true
            isLastSourceElement = !enumerator.MoveNext();

            // If we are (a) at the end of the source, or (b) at the end of the current chunk
            // then null out the enumerator and predicate for reuse with the next chunk.
            if (isLastSourceElement || !predicate(enumerator.Current))
            {
                enumerator = null;
                predicate = null;
            }
            else
            {
                tail.Next = new ChunkItem(enumerator.Current);
            }

            // tail will be null if we are at the end of the chunk elements
            // This check is made in DoneCopyingChunk.
            tail = tail.Next;
        }

        // Called after the end of the last chunk was reached. It first checks whether
        // there are more elements in the source sequence. If there are, it
        // Returns true if enumerator for this chunk was exhausted.
        internal bool CopyAllChunkElements()
        {
            while (true)
            {
                lock (m_Lock)
                {
                    if (DoneCopyingChunk)
                    {
                        // If isLastSourceElement is false,
                        // it signals to the outer iterator
                        // to continue iterating.
                        return isLastSourceElement;
                    }
                    else
                    {
                        CopyNextChunkElement();
                    }
                }
            }
        }

        public TKey Key => key;

        // Invoked by the inner foreach loop. This method stays just one step ahead
        // of the client requests. It adds the next element of the chunk only after
        // the clients requests the last element in the list so far.
        public IEnumerator<TSource> GetEnumerator()
        {
            //Specify the initial element to enumerate.
            ChunkItem current = head;

            // There should always be at least one ChunkItem in a Chunk.
            while (current != null)
            {
                // Yield the current item in the list.
                yield return current.Value;

                // Copy the next item from the source sequence,
                // if we are at the end of our local list.
                lock (m_Lock)
                {
                    if (current == tail)
                    {
                        CopyNextChunkElement();
                    }
                }

                // Move to the next ChunkItem in the list.
                current = current.Next;
            }
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => GetEnumerator();
    }
}

// A simple named type is used for easier viewing in the debugger. Anonymous types
// work just as well with the ChunkBy operator.
public class KeyValPair
{
    public string Key { get; set; }
    public string Value { get; set; }
}

Y luego úsalo como se muestra a continuación:

class Program
{
    // The source sequence.
    public static IEnumerable<KeyValPair> list;

    // Query variable declared as class member to be available
    // on different threads.
    static IEnumerable<IGrouping<string, KeyValPair>> query;

    static void Main(string[] args)
    {
        // Initialize the source sequence with an array initializer.
        list = new[]
        {
            new KeyValPair{ Key = "A", Value = "We" },
            new KeyValPair{ Key = "A", Value = "think" },
            new KeyValPair{ Key = "A", Value = "that" },
            new KeyValPair{ Key = "B", Value = "Linq" },
            new KeyValPair{ Key = "C", Value = "is" },
            new KeyValPair{ Key = "A", Value = "really" },
            new KeyValPair{ Key = "B", Value = "cool" },
            new KeyValPair{ Key = "B", Value = "!" }
        };

        // Create the query by using our user-defined query operator.
        query = list.ChunkBy(p => p.Key);

        // ChunkBy returns IGrouping objects, therefore a nested
        // foreach loop is required to access the elements in each "chunk".
        foreach (var item in query)
        {
            Console.WriteLine($"Group key = {item.Key}");
            foreach (var inner in item)
            {
                Console.WriteLine($"\t{inner.Value}");
            }
        }

        Console.WriteLine("Press any key to exit");
        Console.ReadKey();
    }
}

Consulte el siguiente enlace para obtener más referencia:

Agrupar por claves contagiosas

0