如何在C＃linq asp.net MVC中使用逗号分隔值列连接两个表

Question

I have two tables Profile and CourseList .

Profile table:

ID   | Name   | CourseId
-----+--------+----------
 1   | Zishan |  1,2                                          
 2   | Ellen  |  2,3,4 

CourseList table:

courseid | coursename 
---------+--------------
   1     |  java
   2     |  C++
   3     |  oracle
   4     |  dot net

Here I am joining the two tables and get results and that result in my View page for particular ID like...

If I call ID = 1 in my view:

Name: Zishan,

course name: java,C++

If if i call ID = 2 in my view:

Name: Ellen,

course name: java,C++,oracle.

So I write this Linq query in my controller:

var account = db.Profile.Where(x => x.PId == pid).FirstOrDefault();

string  CourseIDS = string.Join(",",account.CourceId);

var courselist = (from p in db.profile
                  join co in db.CourceList on p.CourceId equals co.courseId 
                  .ToString()  into co1 from co2 in co1.Where(x => 
                   LanguageIDS.Contains(x.courseId.ToString()))
            select new ViewProfileVM
            {
               courseName = string.Join(",", co2.courseName)
            }).FirstOrDefault();

ViewBag.courselist = courselist;

Then I pass ViewBag to view and show results.....

Please help me the linq query is not working and in future i want to add join LanguagesList and CountryList like same as CourceList so please suggest me a simple solution for this issue..

Thanks,

Answer 1

I would second what John M has commented, comma separated values is not a recommended approach in relational Database. But since you have it, you could use following to get your expected result.

var profileList = profiles.SelectMany(x=> x.CourseId.Split(',')
                        .Select(c=> 
                        new 
                        {
                            Name= x.Name, 
                            CourseId = int.Parse(c) 
                        }));
var result = profileList.Join(courses,
                p=>p.CourseId,
                c=>c.Id,
                (p,c)=>new {Name = p.Name, Courses= c.CourseName})
                .GroupBy(x=>x.Name)
                .Select(x=>new 
                {
                Name = x.Key, 
                Courses = string.Join(",",x.ToList().Select(k=>k.Courses))
                });

Where profiles and courses are collection of representiatives classes of your data structures.

public class Profile
{
public int Id{get;set;}
public string Name{get;set;}
public string CourseId{get;set;}
}


public class Coursename
{
public int Id{get;set;}
public string CourseName{get;set;}
}

This would give you expected output as

Name : Zishan Courses : Java,C++

Name:Ellen Courses:C++,Oracle,Dot Net

Following is the sample data i used for testing.

var profiles = new Profile[]
                {
                    new Profile{Id = 1, Name = "Zishan", CourseId = "1,2"},
                    new Profile{Id = 2, Name = "Ellen", CourseId = "2,3,4"}
                };
var courses = new Coursename[]
                {
                    new Coursename{Id=1, CourseName = "Java"},
                    new Coursename{Id=2, CourseName = "C++"},
                    new Coursename{Id=3, CourseName = "Oracle"},
                    new Coursename {Id=4, CourseName = "Dot Net"}
                };

Hope that helps

Answer 2

It seems that every Profile has zero or more Courses , and every Course belongs to zero or more Profiles : a straightforward many-to-many relationship.

Normally in a relational database, this would be implemented using a junction table: a separate table, with two columns that act as foreign keys: ProfileId and CourseId. In your example:

• For Zishan, who has Id 1 we would have [1, 1] and [1, 2], indicating that Zishan attends Courses with Id 1 and 2;
• For Ellen with Id = 2, we would have [2, 2] [2, 3] [2,4].

Alas, your database designer chose not to follow this standard database pattern. And you are stuck with the problems.

The best solution depends a bit on how long you will be stuck with this database, how often it will change, how often you will ask for "Profiles with their Courses" and "Courses with their attendants".

Best Solution: add a junction table to the database

The best solution would be a one-time migration of your database: create the junction table and add the [profile.Id, Course.Id] combinations to this list. After that remove the CourseId column.

class ProfileCourse
{
    public int ProfileId {get; set;}
    public int CourseId {get; set;}
}

var ProfileIdCourseIdCombinations = db.Profiles
    .SelectMany(profile => profile.CourseIds.Split(',", StringSplitOptions.RemoveEmptyEntries),

    (profile, splitCourseId) => new ProfileCourse
    {
         ProfileId = profile.Id,
         CourseId = splitCourseId,
    });

This has to be done only once. Similar queries in future will be fairly standard. Everyone who is a fluent LINQer, will know how to implement the queries. Disadvantage: the database change.

Sub-optimal solution: mimic the junction table

Quite often people have an intermediate (adapter) layer between the use cases and the actual database. This way you can change the database without having to change the users, or vice versa. The pattern for this adapter layer is quite often called the repository pattern.

The Idea is that you create a Repository class that exposes your tables as IEnumerable sequence of items. The junction table will not be a real table, it will be created whenever it is asked for.

class Repository
{
    public Respository(MyDbContext db)
    {
        this.db = db;
    }
    private readonly MyDbContext db;
    private IReadonlyCollection<ProfileCourse> profilesCourses = null;

    public IEnumerable<Profile> Profiles => this.db.Profiles;
    public IEnumerable<Course> Courses => this.db.Courses;

    public IEnumerable<ProfileCourse> ProfilesCourses
    {
         get
         {
             if (this.profilesCourses == null
             {
                 this.profilesCourses = ... // the SelectMany from above
                     .ToList();
             }
             return this.profilesCourses;
         }
    }
}

This way your junction table will be created only once per time you create your Repository. It will only be created when used.

This solution is sub-optimal, because the junction table needs to be recreated every time you'll use it in a new Repository. Furthermore, you can't add Profiles nor Courses using this Repository class. If will be quite some work to create functions to Add / Remove profiles and courses to your Repository. It is possibly easier to recreate the repository.

You'll get your answer by asking the repository instead of your db

var repository = new Repository(db);
var profilesWithTheirCourses = repository.Profiles.GroupJoin(repository.ProfilesCourses,

    profile => profile.Id,                       // from every profile take the Id
    profileCourse => profileCourse.ProfileId,    // from every profileCourse take the ProfileId,

    (profile, profileCourses) => new     // take every profile with all its matching
    {                                    // profileCourses, to make a new obhect
        // Profile properties; add only those you plan to use:
        Id = profile.Id,
        Name = profile.Name,

        Courses = profileCourses.Join(repository.Courses, // join profileCourse with courses
           profileCourse => profileCourse.CourseId,       // from profileCourse take CourseId
           course => course.Id,                            // from course take Id
           (profileCourse, course) => new                  // when they match make a new
           {   // again: only the properties you actually plan to use
               Id = course.Id,
               Name = course.Name,
           })
           .ToList(),
    });

Solution for this problem only

If you decide to make a solution for this problem only, you can combine the SelectMany and the Join into one big LINQ statement.

Advantage: quick solution; Disadvantage: difficult to read, to test, and to maintain. Similar problems in future will have a similar sub-optimal solution,

var profilesWithTheirCourses = db.Profiles.SelectMany(
    profile => profile.CourseIds.Split(',", StringSplitOptions.RemoveEmptyEntries),
    (profile, splitCourseIds) => new
    {
        Id = profile.Id,
        Name = profile.Name,

        Courses = splitCourseIds.Join(db.Courses,
           courseId => courseId,
           course => course.Id,
           (courseId, course) => new
           {
               Id = course.Id,
               Name = course.Name,
           })
           .ToList(),
    });