C＃组列表到新列表

Question

I facing a issue that I cant group my list, I do research and tried different way, but the result is not I want. I not sure if I did something wrong.

List<NewSomeGroup> newsomegourplist = new List<NewSomeGroup>();
var query = from c in _someRepository.Table
                            where  c.isRead == false
                            group c by c.ReferenceId into grpdlist
                            orderby grpdlist.Key
                            select grpdlist;

foreach (var grpdlist in query)
{
    NewSomeGroup somegroup = new NewSomeGroup();
    List<Some> somelist = new List<Some>();
    somegroup.ReferenceId = grpdlist.Key;
    foreach (var item in grpdlist) // not in
    {
        somelist.Add(item);
    }
    somegroup.somecontainlist = somelist;
    newsomegourplist.Add(somegroup);
}

At the end somegroup have correct ReferenceId but somecontainlist have empty object. I very sure it have data inside database, I also tried to debug in localhost and found it //not in doesn't Add the item .

Data Structure

public class NewSomeGroup
{
    public string ReferenceId { get; set; }
    public List<Some> sbnotificationlist { get; set; }
}

public class Some
{
    public string Title { get; set; }
    public string projectid { get; set; }
    public SimpleAccountInfo AccountInfo { get; set; }
    public string Type { get; set; } 
    public string ReferenceId { get; set; }
    public string iconPath { get; set; }
    public DateTime CreateOnUtc { get; set; }
}

Answer 1

Alas you didn't specify your Table , so I'll have to extract the specifications from your code:

input is a Table of rows, where every row is an object that has at least a Boolean property IsRead and a property ReferenceId .

Furthermore, it seems that every row is similar to a Some . A row is not equal to a Some , because rows have a property IsRead while a Some doesn't have this property.

This could be a typing error, or rows could be objects from derived classes of Some . As you didn't specify your table, I'll assume the latter.

Rows in your table don't have to be objects of equal type, but they are at least derived from Some

You want all rows that were not read yet, grouped into groups of rows with same ReferenceId . You want every group converted into one NewSomeGroup object, where the ReferenceId is the common ReferenceId of the elements in the group, and the SbNotificationList is a list, where each element contains the Some values of the rows in the group.

I'm more familiar with method syntax (beside it has more functionality), so my answer will be in method syntax:

var result = myRepository.Table           // from every row in the Table
    .Where(row => !row.IsRead)            // take only those that are not read
    .GroupBy(row => row.ReferenceId)      // make groups of rows with equal ReferenceId
    .Select(group => new NewSomeGroup()   // from every group make one NewSomeGroup object
    {
         ReferenceId = group.Key,
         SbNotificationList = group       // from the sequence of rows in the group
             .Cast<Some>()                // cast every row to a Some
             .ToList(),                   // and put it in a list
    })
    .OrderBy(item => item.ReferenceId);

This will only work if you are absolutely certain that every row in your table really is a Some .

This is the most efficient, because your rows are not copied; the references are put in your final result. Or in other words: your final result contains the original rows.

However, this has the effect that if you change the values of the properties of elements of your SbNotificationList, then the original rows will change.

If you don't want this, or some rows aren't a Some you'll have to create new Some objects with the values from your rows:

.GroupBy(row => row.ReferenceId)
.Select(group => new NewSomeGroup() 
{
    ReferenceId = group.Key,
    SbNotificationList = group       // from the rows in the group make one list
        .Select(row => new Some()    // where every row becomes one Some object
        {
            Title = row.Title,
            ProjectId = row.ProjectId,
            ...
            CreateOnUtc = row.CreateOnUtc, 
         })
         .ToList(),
})
.OrderBy(item => item.ReferenceId);

Whatever method you choose, if your input table is empty or has no rows that aren't read, your result will still be a sequence of NewSomeGroup objects, however this sequence will be empty (that is something different than null!).

If your input table has one or more rows that are read, your result won't be empty. Every NewSomeGroup in your result will have a non-empty SbNotificationList , containing the Some values of all rows that had a ReferenceId equal to the ReferenceId of the NewSomeGroup object.

That is a difficult way to say that it can't be that any NewSomeGroup object in your final result has an empty SbNotificationList . You can Debug.Assert on this

Answer 2

You can try the below code:

somegroup.somecontainlist.AddRange(somelist);

or You can try this:

somegroup.somecontainlist = new List<SomeDataType>(somelist);

or if you're using C# 3 and .NET 3.5, with Linq, you can do this:

somegroup.somecontainlist = somelist.ToList();