Question

I have two Generic lists having objects of class :

class Subject
 {
   public string Code { get; set; }
   public string Name { get; set; }
 }

And another class as below :

class Student
{
    public string RollNo { get; set; }
    public string Name { get; set; 
}

And a List of type having Roll No and Subject codes as KeyValuePair for student as below :

List<KeyValuePair<string,string>>  RoleList=
           new  List<KeyValuePair<string,string>> ();

Student st1=new Student();          
Subject sb1=new Subject();
Subject sb2=new Subject();
Subject sb3=new Subject();

RoleList.Add(new KeyValuePair<string,string>(st1.RollNo,sb1.Code));
RoleList.Add(new KeyValuePair<string,string>(st1.RollNo,sb2.Code));
RoleList.Add(new KeyValuePair<string,string>(st1.RollNo,sb3.Code));

What I need is another Dictionary of type

Dictionary<string, List<Subject>> StSbList =
    new Dictionary<string, List<Subject>>();

where StSbList should have a list of subjects for given student using dictionary RoleList having all the subjects for a given Roll No. using LINQ in C# 4.0 , something like

 StSbList(st1.RollNo, {sb1,sb2,sb3});

I tried and was able merge to similar collections but struck with different type of collections. Any suggestions on any other better approach.

As rightly pointed by Douglas and Martin, both the solutions are working fine but on my test data ToLookup works faster so used the same.

Solution 1

Dictionary<string, List<Subject>> stSbList =
RoleList.GroupBy(kvp => kvp.Key)
        .ToDictionary(
            grouping => grouping.Key,
            grouping => grouping.Select(kvp => (from sub in listSub
                                                where sub.Code.Equals(kvp.Value)
                                                select sub).First()).ToList(),
            EqualityComparer<string>.Default);

Solution 2

var tSbList = RoleList.ToLookup(kvp => kvp.Key, kvp => 
             (from sub in listSub
              where sub.Code.Equals(kvp.Value)
              select sub).First());

Answer 1

Your question isn’t really clear. If you’re asking for an example of how to populate your dictionary, here’s one:

Dictionary<string, List<Subject>> stSbList = new Dictionary<string, List<Subject>>();
stSbList.Add(st1.RollNo, new List<Subject> { sb1, sb2, sb3 });
stSbList.Add(st2.RollNo, new List<Subject> { sb1, sb3 });
stSbList.Add(st3.RollNo, new List<Subject> { sb1, sb2 });

More succinctly using nested collection initializers:

Dictionary<string, List<Subject>> stSbList = new Dictionary<string, List<Subject>>
{
    { st1.RollNo, new List<Subject> { sb1, sb2, sb3 } },
    { st2.RollNo, new List<Subject> { sb1, sb3 } },
    { st3.RollNo, new List<Subject> { sb1, sb2 } },
};

Update: As others have pointed out, your definition of RoleList as a dictionary is probably erroneous, since it will not allow you to define multiple subjects for the same student. What you need is a data structure that supports the representation of a many-to-many relation; for example, a List<T> of Tuple<string,string>, where Item1 of each tuple contains the Student.RollNo, whilst Item2 contains the Subject.Code:

var roleList = new List<Tuple<string, string>>();
roleList.Add(Tuple.Create(st1.RollNo, sb1.Code));
roleList.Add(Tuple.Create(st1.RollNo, sb2.Code));
roleList.Add(Tuple.Create(st1.RollNo, sb3.Code));
roleList.Add(Tuple.Create(st2.RollNo, sb1.Code));
roleList.Add(Tuple.Create(st2.RollNo, sb3.Code));
roleList.Add(Tuple.Create(st3.RollNo, sb1.Code));
roleList.Add(Tuple.Create(st3.RollNo, sb2.Code));

To convert this into a dictionary, you could use first use the GroupBy operator, followed by ToDictionary:

var subjects = new[] { sb1, sb2, sb3 }.ToDictionary(sb => sb.Code);

Dictionary<string, List<Subject>> stSbList =
    roleList.GroupBy(tuple => tuple.Item1)
            .ToDictionary(
                grouping => grouping.Key,
                grouping => grouping.Select(tuple => subjects[tuple.Item2]).ToList(),
                EqualityComparer<string>.Default);

Update₂: For completeness, this is how to construct the dictionary from your definition of RoleList (although this probably isn’t what you want):

var roleList = new Dictionary<string, string>();
roleList.Add(st1.RollNo, sb1.Code);
roleList.Add(st2.RollNo, sb2.Code);
roleList.Add(st3.RollNo, sb2.Code);

var subjects = new[] { sb1, sb2, sb3 }.ToDictionary(sb => sb.Code);

Dictionary<string, List<Subject>> stSbList = roleList.ToDictionary(
    kvp => kvp.Key,
    kvp => new List<Subject> { subjects[kvp.Value] });

Update₃: Adapted to work with the latest version of your code:

var subjects = new[] { sb1, sb2, sb3 }.ToDictionary(sb => sb.Code);

Dictionary<string, List<Subject>> stSbList =
    RoleList.GroupBy(kvp => kvp.Key)
            .ToDictionary(
                grouping => grouping.Key,
                grouping => grouping.Select(kvp => subjects[kvp.Value]).ToList());