C# - LINQ - Sortieren und gruppieren ein Dictionary<string,DateTime> nach Datum und mit maximale Größe der Gruppe

Ich bin auf der Suche, um erstellt Chargen von einem Dictionary<string, DateTime> mit den folgenden Einschränkungen:

Alle Elemente im batch-viel teilen das gleiche Datum
Es kann nicht mehr als X Elemente in einem einzigen batch. Wenn es mehrere Elemente mit dem gleichen Datum, eine batch erstellt werden muss.

Bin, habe ich mir folgende Logik, aber Frage mich, ob es einigen anderen mehr prägnanten Art und Weise, dies zu tun, nur mit linq.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace dictionary_sort_by_value_test
{
    class Program
    {
        static void Main(string[] args)
        {
            int maxBatchSize = 3;

            Dictionary<string, DateTime> secs = new Dictionary<string, DateTime>();
            secs.Add("6571 JT", new DateTime(2011, 1, 10));
            secs.Add("6572 JT", new DateTime(2011, 1, 12));
            secs.Add("6573 JT", new DateTime(2011, 1, 12));
            secs.Add("6574 JT", new DateTime(2011, 1, 12));
            secs.Add("6575 JT", new DateTime(2011, 1, 10));
            secs.Add("6576 JT", new DateTime(2011, 1, 11));
            secs.Add("6577 JT", new DateTime(2011, 1, 11));
            secs.Add("6578 JT", new DateTime(2011, 1, 11));
            secs.Add("6579 JT", new DateTime(2011, 1, 11));

            var sorted = secs.OrderBy(o => o.Value).GroupBy(o => o.Value);

            foreach (var date in sorted)
            {    
                Console.Write("\nNew batch at {0} \n", date.Key);
                int batchsize = 0;
                foreach (var sec in date)
                {
                    if (batchsize < maxBatchSize)
                    {
                        Console.Write("  {0} {1} \n", sec.Key, sec.Value);
                        batchsize++;
                    }
                    else
                    {
                        Console.Write("\nNew batch at {0} \n", date.Key);
                        Console.Write("  {0} {1} \n", sec.Key, sec.Value);
                        batchsize = 1;
                    }
                }
            }
        }
    }
}

Ich sehe nicht, wo/wie du bist erstellen eine neue Ladung in Ihrem code. Sie sind das zählen der Anzahl der batches, die aber nicht jedem anlegen einer neuen charge und hinzufügen, um Ihre "Ergebnis". Ich persönlich der einzige Weg, Sie könnte dies nur mithilfe von LINQ wäre, noch ein tie-breaker, so können Sie die Gruppe, indem Sie diese als gut. Oder implementieren Sie Ihre Logik als Extension method auf IEnumerable<T>. So, es schauen, wie LINQ, fühlen Sie sich wie LINQ und es wird LINQ denn das ist, wie LINQ implementiert ist, sowieso.

InformationsquelleAutor Andre P. | 2011-02-23

Sie die Gruppe, indem Sie Ihre Schlüssel, dann im Ergebnis die Gruppe durch das Element, index, geteilt durch die gewünschte chunk-Größe.

var chunkSize = 3;
var sorted = secs
    .OrderBy(kv => kv.Key)
    .GroupBy(o => o.Value)
    .Select(g => new {Chunks = g.Select((o,i) => new {Val = o, Index = i})
                                .GroupBy(item => item.Index / chunkSize)});

Und die Anzeige:

 foreach(var item in sorted.SelectMany(item => item.Chunks))
 {
     Console.WriteLine("New batch at " + item.First().Val.Value);
     foreach(var element in item)
         Console.WriteLine(element.Val.Key);
}

Danke. Das ist genau das, was ich suchte.

InformationsquelleAutor Yann Schwartz

Nicht unbedingt mit linq um Ihre Probleme zu lösen, sondern eine lapidare Umgang mit der iteration:

static void Main(string[] args)
{
    int maxBatchSize = 3;

    Dictionary<string, DateTime> secs = new Dictionary<string, DateTime>();
    secs.Add("6571 JT", new DateTime(2011, 1, 10));
    secs.Add("6572 JT", new DateTime(2011, 1, 12));
    secs.Add("6573 JT", new DateTime(2011, 1, 12));
    secs.Add("6574 JT", new DateTime(2011, 1, 12));
    secs.Add("6575 JT", new DateTime(2011, 1, 10));
    secs.Add("6576 JT", new DateTime(2011, 1, 11));
    secs.Add("6577 JT", new DateTime(2011, 1, 11));
    secs.Add("6578 JT", new DateTime(2011, 1, 11));
    secs.Add("6574 JT", new DateTime(2011, 1, 11));
    secs.Add("6579 JT", new DateTime(2011, 1, 11));
    secs.Add("6580 JT", new DateTime(2011, 1, 11));
    secs.Add("6581 JT", new DateTime(2011, 1, 11));
    secs.Add("6582 JT", new DateTime(2011, 1, 11));
    secs.Add("6583 JT", new DateTime(2011, 1, 11));

    secs.OrderBy(o => o.Value).GroupBy(o => o.Value).ToList().ForEach(date =>
                   {
                       Console.Write("\nNew batch at {0} \n", date.Key);
                       int batchsize = 0;
                       foreach (var sec in date)
                       {
                           if (batchsize >= maxBatchSize)
                           {
                               Console.Write("\nNew batch at {0} \n", date.Key);
                               batchsize = 0;
                           }

                           Console.Write("  {0} {1} \n", sec.Key, sec.Value);
                           batchsize++;
                       }
                   });

    Console.ReadLine();
}

InformationsquelleAutor Leom Burke

Können Sie es mit 2 GroupBys. Erste Gruppe von DateTime, und dann group by-Seite. Ich musste angeben, die generische Argumente explizit auf, weil der compiler wurde die Kommissionierung der falschen überlast-und das machte den Abfrage-code mehr.

var groups = secs.GroupBy<KeyValuePair<string, DateTime>, DateTime, string, Group>(
    p => p.Value,
    p => p.Key,
    (d, g) => new Group {
        Date = d,
        Pages = g.Select((s, i) => new KeyValuePair<string, int>(s, i / maxBatchSize))
            .GroupBy<KeyValuePair<string, int>, int, string, Page>(
                p => p.Value,
                p => p.Key,
                (p, g2) => new Page { Id = p, Items = g2.ToList() }) });

foreach (var group in groups)
{
    Console.WriteLine("Date: {0}", group.Date);
    foreach (var page in group.Pages)
    {
        Console.WriteLine("Page: {0}", page.Id);
        foreach (var key in page.Items)
            Console.WriteLine(key);
    }
}

Wie Sie sehen können, ich hatte zu definieren, 2 Klassen, weil, wie ich sagte, ich musste angeben, die generische Argumente, denn die Verwendung von anonymen Typen aus der überlast-Auflösung wählen Sie eine andere überladung.

class Group
{
    public DateTime Date;
    public IEnumerable<Page> Pages;
}

class Page
{
    public int Id;
    public IEnumerable<string> Items;
}

Hoffe, das hilft.

InformationsquelleAutor Fede

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.