Error when converting a foreach into linq

Question

I have an application that creates courses for a university and adds students to the created courses. I pass the course info from my frontend using a dto for data security. The code in my service, using a foreach works, but the one with the linq does not. The code for my entities, which are students and courses, and my service is below:

    public class Student
{
    public string studentName {get; set;}
    public int idCourse {get; set;}
}


public class Course
{
    public Course()
    {
        Students = new List<Student>();
    }
    public int id {get; set;}
    public string courseName {get; set;}
    public ICollection<Student> Students {get; set;}
    
}

public class CourseDTO
{
    public string courseNameDTO {get; set;}
    public List<string> StudentsFromDTO {get; set;}
}

public class Service(CourseDTO dto)
{
    Course createdCourse = new Course
    {
        courseName = dto.courseNameDTO;
    }
    
    foreach(var studentToAdd in dto.StudentsFromDTO)
    {
        var student = new Student
        {
            idCourse = createdCourse.id;
            studentName = studentToAdd;
        }
        
        createdCourse.Students.Add(student);
    }
    
    // add the created course in the database
}

Basically, a course has many students, which are added after the new course is created. In my service I loop through the students names and add each of the individually which is not the most efficient, so I tried to write a linq, but it doesn't work:

createdCourse =  createdCourse.AddRange(dto.StudentsFromDTO.Select(s => new Student { idCourse = createdCourse.id;
        studentName = s; }));

Any way to refactor the code to be fewer lines or a better linq? Cheers!

Answer 1

Your code does not compile because:

1. You declare Students as an ICollection<Student>, but ICollection<T> does not have a method AddRange(). Only the concrete implementation List<T> has AddRange().

   See AddRange to a Collection for details.

   And of course Course does not have AddRange() because you never implemented such a method, so neither createdCourse.AddRange(...) nor createdCourse.Students.AddRange(..) will compile.

2. You are using semicolons in your object initializers:

   new Student { idCourse = createdCourse.id; studentName = s; }
   

   You must use commas.

If you are looking for a one-line method to add all the students to Course.Students, you could use List<T>.Foreach():

public static Course FromDTO(CourseDTO dto)
{
    // How is Course.id set?
    Course createdCourse = new () { courseName = dto.courseNameDTO };
    dto.StudentsFromDTO.ForEach(name => createdCourse.Students.Add(new() { idCourse = createdCourse.id, studentName = name }));
    
    return createdCourse;
}

Note the use of the target-typed new() operator (introduced in C# 9.0) to simplify the syntax for object creation when the type can be inferred from the context.

Demo #1 here.

Alternatively, you could introduce the extension method by TrueWill from AddRange to a Collection:

public static class CollectionHelpers
{
    //https://stackoverflow.com/questions/1474863/addrange-to-a-collection
    public static void AddRange<T>(this ICollection<T> destination,
                                   IEnumerable<T> source)
    {
        foreach (T item in source)
        {
            destination.Add(item);
        }
    }
}

And do:

public static Course FromDTO(CourseDTO dto)
{
    // How is Course.id set?
    Course createdCourse = new () { courseName = dto.courseNameDTO };
    createdCourse.Students.AddRange(dto.StudentsFromDTO.Select(name => new Student { idCourse = createdCourse.id, studentName = name }));
    
    return createdCourse;
}

You can't use a target-typed new() for Student in this case.

Demo #2 here.

While both these approaches are more concise than your current code, there is no reason to believe they are more efficient. Your current code and my alternatives all map a collection of one type to a collection of another type in linear time, which would seem to be as efficient as possible.