0

I want to convert list of NoteModel objects to list of objects as following.

Final result should be contain list of GroupNoteModels objects which contains Date and list of GroupItemModel objects with respective date.

public class NoteModel
{
    public DateTime Date { get; set; }
    public int NoteID { get; set; }
    public string Text { get; set; }
}

Initialize and add notes to noteList

private List<NoteModel> noteList = new List<NoteModel>();

public void AddNotes()
{
    aodList.Add(new AODModel(DateTime.Now, 1, "Text1"));
    aodList.Add(new AODModel(DateTime.Now.AddDays(1), 2, "Text2"));
    aodList.Add(new AODModel(DateTime.Now.AddDays(1), 3, "Text3"));
}

Models using for List of lists

public class GroupItemModel
{
    public int NoteID { get; set; }
    public string Text { get; set; }
}

public class GroupedNoteModel
{
    public DateTime Date { get; set; }
    public List<GroupItemModel> noteWithSameDateList { get; set; }
}

Code I've tried

var noteGrouped = noteList.GroupBy(a => a.Date )
                    .Select(a => new
                    {
                        Date= a.Select(x=>x.Date ),
                        noteWithSameDateList= new {
                            NoteID = a.Select(x=>x.NoteID ),
                            Text= a.Select(x => x.Text)
                        } 
                    }).ToList();

List<GroupedNoteModel> noteGroupList = noteGrouped;
Alexander Raymak
  • 11
  • 4

2 Answers2

2

Looping solution

Since I'm not really involved with SQL and LINQ grouping, we can write that to distribute the data:

var notesByDate = new List<GroupedNoteModel>();

foreach ( var note in notesById )
{
  GroupedNoteModel item = notesByDate.Find(n => n.Date == note.Date);
  if ( item == null )
  {
    item = new GroupedNoteModel();
    item.NoteWithSameDateList = new List<GroupItemModel>();
    item.Date = note.Date;
    notesByDate.Add(item);
  }
  var subitem = new GroupItemModel();
  subitem.NoteID = note.NoteID;
  subitem.Text = note.Text;
  item.NoteWithSameDateList.Add(subitem);
}

Test

var date = DateTime.Now;

var notesById = new List<NoteModel>();

notesById.Add(new NoteModel { Date = date.AddDays(0), NoteID = 1, Text = "Note 1" });
notesById.Add(new NoteModel { Date = date.AddDays(1), NoteID = 2, Text = "Note 2" });
notesById.Add(new NoteModel { Date = date.AddDays(2), NoteID = 3, Text = "Note 3" });
notesById.Add(new NoteModel { Date = date.AddDays(0), NoteID = 4, Text = "Note 4" });
notesById.Add(new NoteModel { Date = date.AddDays(2), NoteID = 5, Text = "Note 5" });

foreach ( var item in notesByDate )
{
  Console.WriteLine(item.Date);
  foreach ( var note in item.NoteWithSameDateList)
  {
    Console.WriteLine($"     {note.NoteID}: {note.Text}");
  }
}

Output

21/08/2021 07:56:11
     1: Note 1
     4: Note 4
22/08/2021 07:56:11
     2: Note 2
23/08/2021 07:56:11
     3: Note 3
     5: Note 5

Clean refactoring

In addition to providing constructors for the entities, a composite should probably be used for NoteWithSameDateList otherwise there might be issues like null reference exception when using the resulting dispatched data:

Understanding the Aggregation, Association, Composition

What is the difference between association, aggregation and composition?

foreach ( var note in notesById )
{
  GroupedNoteModel item = notesByDate.Find(n => n.Date == note.Date);
  if ( item == null )
  {
    item = new GroupedNoteModel(note.Date);
    notesByDate.Add(item);
  }
  item.NoteWithSameDateList.Add(new GroupItemModel(note.NoteID, note.Text));
}

notesById.Add(new NoteModel(date.AddDays(0), 1, "Note 1"));
notesById.Add(new NoteModel(date.AddDays(1), 2, "Note 2"));
notesById.Add(new NoteModel(date.AddDays(2), 3, "Note 3"));
notesById.Add(new NoteModel(date.AddDays(0), 4, "Note 4"));
notesById.Add(new NoteModel(date.AddDays(2), 5, "Note 5"));

public class NoteModel
{
  public DateTime Date { get; set; }
  public int NoteID { get; set; }
  public string Text { get; set; }
  public NoteModel(DateTime date, int id, string text)
  {
    Date = date;
    NoteID = id;
    Text = text;
  }
}

public class GroupItemModel
{
  public int NoteID { get; set; }
  public string Text { get; set; }
  public GroupItemModel(int id, string text)
  {
    NoteID = id;
    Text = text;
  }
}

public class GroupedNoteModel
{
  public DateTime Date { get; set; }
  public List<GroupItemModel> NoteWithSameDateList { get; }
  public GroupedNoteModel(DateTime date)
  {
    NoteWithSameDateList = new List<GroupItemModel>();
    Date = date;
  }
}

Alternative

public class GroupedNoteModel
{
    public DateTime Date { get; set; }
    public List<GroupItemModel> NoteWithSameDateList { get; }
      = new NoteWithSameDateList()
}
1

The output from a groupby operation is something like a "list of groupings" and a grouping is something like a "list of the original objects plus a Key property that they all share as the same"

So as a simpler example

  [
    {name:John, age:23},
    {name:Jim,  age:23},
    {name:Jack, age:24}
  ]

"Group By age" produces

[
  {Key: 23, [{name:John, age:23},{name:Jim,  age:23}]},
  {Key: 24, [{name:Jack, age:24}]},
]

It's a bit hard to represent in "JSON" because the Grouping (the object with the Key property) is-a list, rather than has-a list

So, in summary "list of X in, grouped by X.Y, produces list-of-grouping and a grouping itself is a list-of-X-with-Key-of-same-X.Y"

In your code:

var noteGrouped = noteList.GroupBy(a => a.Date )
                    .Select(a => new
                    {
                        Date= a.Select(x=>x.Date ),
                        noteWithSameDateList= new {
                            NoteID = a.Select(x=>x.NoteID ),
                            Text= a.Select(x => x.Text)
                        } 
                    }).ToList();

List<GroupedNoteModel> noteGroupList = noteGrouped;

I find it best to always think carefully about what to call the parameter to the lambda - you've just called yours "a" in both cases, but one is a NoteModel and one is a Grouping. Remember that your grouping are "enumerable with a Key property, which is what was grouped/what they all share ie a DateTime in your case"

For starters this means you should have "note" or "n" in your groupby (because it is operating on NoteModels) and "grp" or "g" in your first select (because is operating on Groupings, which are lists of NoteModels)

Also your Date property in your output model should definitely be the Key of the grouping

NoteWithSameDate should be a conversion of the "list of notes" (which is what a grouping is) into a "list of groupitemmodel"

var noteGrouped = noteList
    .GroupBy(n => n.Date ) //n is a NoteModel
    .Select(grp => new GroupedNoteModel() //you'd made an anonymous type here when you wanted to make one of these
        { 
            Date = grp.Key,
            noteWithSameDateList= grp.Select(note => //grp is a "list" of NoteModel. 'note' here is a single notemodel
                new GroupItemModel() //not an anonymous type
                {
                    NoteID = note.NoteId,
                    Text= note.Text
                }
            ).ToList() //turn.   grp.Select(note...   into a list
        }
    ).ToList(); //turn.  .Select(grp...   into a list

Final minor note, earlier in the answer I talked about the output from a groupby being a list of grouping and a grouping being a list of your original objects. I use the term list colloquially to refer to some enumerable collection; it isn't literally a List<IGrouping> and an IGrouping isn't literally a List<T> - it's just easier to understand the phrase "list of lists" than the crazy amount of generic types involved in a group by ("an ienumerable of ienumerable igroupings")

There are other overloads of GroupBy that are more complex; they take lambdas themselves to perform conversions of the input objects directly to output without follow up Select operations, but I recommend wrapping your head around the simple "group by date, get a list of list-of-those-with-same-date" for now..

Caius Jard
  • 72,509
  • 5
  • 49
  • 80