Question

I’m looking at the following code

    public IEnumerable<RoleRecord> GetRoles() {
        var roles = _roleRepository.Table.Select(role => role);
        return roles.ToList();
    }

the Table is IQueryable<RoleRecord> Table { get; }

Is there a better way to write this?

Answer 1

The Select(role => role) effectively projects to itself – so basically does nothing here.

return  _roleRepository.Table.ToList();

…will achieve the same, or:

return _roleRepository.Table;

If you are happy returning the enumerable and not a resolved list.

This is making the guess that Table is a valid IEnumerable<T> to be eligible for Select() or ToList().

The ToList would fully iterate the Table enumerable, but is returned as an IEnumerable<T>. Consumers of that are going to be iterating the list, which might be cheaper than iterating the Table.

Update: after chatting with @servy, one important difference between returning an IEnumerable<T> (in your case, from Select(role => role)) and returning a List<T> is that with a List<T>, the caller can cast your IEnumerable<T> back to a List<T> and mutate it:

IEnumerable<RoleRecord> results = GetRoles();
var asList = (List<RoleRecord>)results;
asList.Add(new RoleRecord());
asList.RemoveAt(0);

Do note, however, that the self-projection isn’t the deciding factor here, it is the fact that you are using an iterator block as the IEnumerable<T> implementation and not a List<T>.

That said, this particular behavioural difference won’t be apparent in your case because you call ToList(), so the code in the original answer stands – it is equivalent (and technically slightly faster).