Geek Answers Handbook

LINQ query nested question

Today I ran into a problem, and for a while I was at a standstill trying to find the results that I am looking for.

I currently have a class similar to the following:

public class InstanceInformation
{
     public string PatientID {get; set;}
     public string StudyID {get; set;}
     public string SeriesID {get; set;}
     public string InstanceID {get; set;}
}

I have List<InstanceInformation>, and I'm trying to use LINQ (or any other ways to generate paths ( for a file directory ) based on this list, which looks like this:

PatientID/StudyID/SeriesID/InstanceID

My problem is that the data is currently unstructured, as in the previous form (List), and I need a way to group all the data with the following restrictions:

  • SeriesID Group Instance Identifiers
  • StudyID Group Identifiers
  • Group ResearchID Using PatientID

I currently have something similar to this:

var groups = from instance in instances
             group instance by instance.PatientID into patientGroups
             from studyGroups in
                 (from instance in patientGroups
                   group instance by instance.StudyID)
                   from seriesGroup in
                       (from instance in studyGroups
                        group instance by instance.SeriesID)
                            from instanceGroup in
                                 (from instance in seriesGroup
                                  group instance by instance.InstanceID)
             group instanceGroup by patientGroups.Key;

InstanceID PatientID, , , (StudyID/SeriesID). .

- ( foreach)

+5
6

, , , - , , , , , , .

, , - 7.16.2.1 # 4, :

from ... into x ...


from x in ( from ... ) ...

? , :

var groups = from instance in instances
             group instance by instance.PatientID into patientGroups
             from studyGroups in
                 **** (from instance in patientGroups
                   group instance by instance.StudyID) ****
                   from seriesGroup in
                       (from instance in studyGroups
                        group instance by instance.SeriesID)
                            from instanceGroup in
                                 (from instance in seriesGroup
                                  group instance by instance.InstanceID)
             group instanceGroup by patientGroups.Key;


from studyGroups in ( from ... ) ...

spec ,

from ... into studyGroups ...


var groups = from instance in instances
             group instance by instance.PatientID into patientGroups
             from instance in patientGroups
             group instance by instance.StudyID into studyGroups
             from seriesGroup in
             **** (from instance in studyGroups
                  group instance by instance.SeriesID) ****
                      from instanceGroup in
                           (from instance in seriesGroup
                            group instance by instance.InstanceID)
             group instanceGroup by patientGroups.Key;

.

from seriesGroup in (from ... ) ...

, ,

from ... into seriesGroup ...

:

var groups = from instance in instances 
             group instance by instance.PatientID into patientGroups
             from instance in patientGroups 
             group instance by instance.StudyID into studyGroups
             from instance in studyGroups
             group instance by instance.SeriesID into seriesGroup
             from instanceGroup in
              ****     (from instance in seriesGroup
                   group instance by instance.InstanceID) ****
             group instanceGroup by patientGroups.Key;

!

var groups = from instance in instances 
             group instance by instance.PatientID into patientGroups
             from instance in patientGroups 
             group instance by instance.StudyID into studyGroups
             from instance in studyGroups
             group instance by instance.SeriesID into seriesGroup
             from instance in seriesGroup
             group instance by instance.InstanceID into instanceGroup
             group instanceGroup by patientGroups.Key;

, , . , , "" :

var groups = from instance in instances 
             group instance by instance.PatientID into patientGroups
             from patientGroup in patientGroups 
             group patientGroup by instance.StudyID into studyGroups
             from studyGroup in studyGroups
             group studyGroup by studyGroup.SeriesID into seriesGroups
             from seriesGroup in seriesGroups
             group seriesGroup by seriesGroup.InstanceID into instanceGroup
             group instanceGroup by patientGroups.Key;

, , , , , , , , .

. , , .

+11

, , :

public class InstanceInformation {
    public string PatientID { get; set; }
    public string StudyID { get; set; }
    public string SeriesID { get; set; }
    public string InstanceID { get; set; }

    public override string ToString() {
        return String.Format("Series = {0} Study = {1} Patient = {2}", SeriesID, StudyID, PatientID);
    }
}

class Program {
    static void Main(string[] args) {
        List<InstanceInformation> infos = new List<InstanceInformation>() {
            new InstanceInformation(){ SeriesID = "A", StudyID = "A1", PatientID = "P1" },
            new InstanceInformation(){ SeriesID = "A", StudyID = "A1", PatientID = "P1" },
            new InstanceInformation(){ SeriesID = "A", StudyID = "A1", PatientID = "P2" },
            new InstanceInformation(){ SeriesID = "A", StudyID = "A2", PatientID = "P1" },
            new InstanceInformation(){ SeriesID = "B", StudyID = "B1", PatientID = "P1"},
            new InstanceInformation(){ SeriesID = "B", StudyID = "B1", PatientID = "P1"},
        };

        IEnumerable<IGrouping<string, InstanceInformation>> bySeries = infos.GroupBy(g => g.SeriesID);
        IEnumerable<IGrouping<string, InstanceInformation>> byStudy = bySeries.SelectMany(g => g.GroupBy(g_inner => g_inner.StudyID));
        IEnumerable<IGrouping<string, InstanceInformation>> byPatient = byStudy.SelectMany(g => g.GroupBy(g_inner => g_inner.PatientID));

        foreach (IGrouping<string, InstanceInformation> group in byPatient) {
            Console.WriteLine(group.Key);
            foreach(InstanceInformation II in group)
                Console.WriteLine("  " + II.ToString());
        }
}
+2

tostring; .

    public class InstanceInformation
    {
        public string PatientID { get; set; } public string StudyID { get; set; } public string SeriesID { get; set; } public string InstanceID { get; set; }
        public override string ToString()
        {
            var r = string.Format("{0}/{1}/{2}/{3}", PatientID, StudyID, SeriesID, InstanceID);
            return r;
        }
    } 

var listofstring = list.ConvertAll<string>(x => x.ToString()).ToList();
var listofstringdistinct = listofstring.Distinct().ToList();

.

+2

, , ( ) (...), , (.. PatientID/StudyID/SeriesID/InstanceID):

var byPatient = new Dictionary<string, Dictionary<string, Dictionary<string, Dictionary<string, InstanceInformation>>>>();
foreach (var patientGroup in instances.GroupBy(x => x.PatientID))
{
    var byStudy = new Dictionary<string, Dictionary<string, Dictionary<string, InstanceInformation>>>();
    byPatient.Add(patientGroup.Key, byStudy);
    foreach (var studyGroup in patientGroup.GroupBy(x => x.StudyID))
    {
        var bySeries = new Dictionary<string, Dictionary<string, InstanceInformation>>();
        byStudy.Add(studyGroup.Key, bySeries);
        foreach (var seriesIdGroup in studyGroup.GroupBy(x => x.SeriesID))
        {
            var byInstance = new Dictionary<string, InstanceInformation>();
            bySeries.Add(seriesIdGroup.Key, byInstance);
            foreach (var inst in seriesIdGroup)
            {
                byInstance.Add(inst.InstanceID, inst);
            }
        }
    }
}

P.S.
InstanceID .

: Dictionary<string, List<InstanceInformation>>

EDIT:

, , GroupBy, OrderBy().ThenBy()...

foreach (var el in instances.OrderBy(x => x.PatientID)
                            .ThenBy(x => x.StudyID)
                            .ThenBy(x => x.SeriesID)
                            .ThenBy(x => x.InstanceID))
{
    // it yields:
    // Pat1 Std1 Srs1 Inst1
    // Pat1 Std1 Srs1 Inst2
    // Pat1 Std1 Srs2 Inst1
    // Pat1 Std2 Srs2 Inst2
    // ...
}
+2

Linq .

 var groups = from instance in instances
                        group instance by instance.PatientGuid into patientGroups
                        select new
                        {
                            patientGroups.Key,
                            StudyGroups = from instance in patientGroups
                                          group instance by instance.StudyGuid into studyGroups
                                          select new 
                                          { 
                                          studyGroups.Key,
                                          SeriesGroups = from c in studyGroups
                                                         group c by c.SeriesGuid into seriesGroups
                                                         select seriesGroups
                                          }

                        };

foreach . .

foreach (var patientGroups in groups)
             {
                 Console.WriteLine("Patient Level = {0}", patientGroups.Key);
                 foreach (var studyGroups in patientGroups.StudyGroups)
                 {
                     Console.WriteLine("Study Level = {0}", studyGroups.Key);
                     foreach (var seriesGroups in studyGroups.SeriesGroups)
                     {
                         Console.WriteLine("Series Level = {0}", seriesGroups.Key);
                         foreach (var instance in seriesGroups)
                         {
                             Console.WriteLine("Instance Level = {0}", instance.InstanceGuid);
                         }
                     }
                 }

             }

, , . .

+1

, , " " ( into).

, , GroupBy. LINQ , , :

var groups = instances.
    GroupBy(instance => instance.PatientID).
    GroupBy(patientGroup => patientGroup.StudyID).
    GroupBy(studyGroup => studyGroup.SeriesID).
    GroupBy(seriesGroup => seriesGroup.InstanceID).
    GroupBy(instanceGroup => patientGroups.Key);

(I don’t know if this is really what you are looking for - I just did a “syntactic conversion” of what Eric wrote - and I believe that I did not change the meaning of Eric's request)

EDIT There might be some kind of trompe l'oeil with the latter group by, because it is not completely regular.

+1
source

More articles:


All Articles