Update 3/31/2017
I've learned a few more things since this post, so want to give one important reason to use ToList
when returning from the repository - calling ToList
will (when using IQueryable) execute the translated SQL on the database instead of pulling records into memory and then filtering. I don't believe the implicit cast to IEnumerable or IList does this.
Following some of the tutorials on the MSDN website, I have utilized the generic repository layer in my application. This repository layer is called by my service layer, which is in turn called by the controller.
Looking at the generic repository, the data is fetched and is returned by calling ToList()
. However, the return type of the method is IEnumerable
which means the service layer must accept IEnumerable
and before returning to the controller it must once again call a ToList()
on the IEnumerable
.
Example - Repository:
public IEnumerable<TEntity> Get(
Expression<Func<TEntity, bool>> filter = null,
Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null,
string includeProperties = "")
{
IQueryable<TEntity> query = dbSet;
if (filter != null)
{
query = query.Where(filter);
}
foreach (var includeProperty in includeProperties.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
{
query = query.Include(includeProperty);
}
return orderBy != null ? orderBy(query).ToList() : query.ToList();
}
Example - Service Layer
public IList<DOC> SearchDocuments(string docInfo)
{
// build the predicate and logic, etc
// grab all the matching documents with the relationships
IEnumerable<DOC> documents = _unitOfWork.DocumentRepository.Get(
predicate,
p => p.OrderBy(d => d.DocInfo),
"DocRelationship, DocRelationship.OtherDocTable");
return documents.ToList();
}
From the reading that I've done, it seems to be best to simply present to the controller a List
of objects that it needs versus an IEnumerable
or IQueryable
.
Therefore, I think it would be better to instead of returning an IEnumerable
to return an IList
instead. Am I missing something here - why did the MSDN team choose IEnumerable
for the design and call ToList
? Where would this be useful?? In my eyes it seems to be inefficient and pointless to do that conversion more than once, especially if dealing with a large set of data.
I apologize in advance if this is not clear or there is already an answer, but I have been searching and reading the other posts IEnumerable vs IQueryable vs IList, but I still do not understand this particular issue.