Repository Interface - Available Functions & Filtering Output

Question

I've got a repository using LINQ for modelling the data that has a whole bunch of functions for getting data out. A very common way of getting data out is for things such as drop down lists. These drop down lists can vary. If we're creating something we usually have a drop down list with all entries of a certain type, which means I need a function available which filters by the type of entity. We also have pages to filter data, the drop down lists only contain entries that currently are used, so I need a filter that requires used entries. This means there are six different queries to get the same type of data out.

The problem with defining a function for each of these is that there'd be six functions at least for every type of output, all in one repository. It gets very large, very quick. Here's something like I was planning to do:

public IEnumerable<Supplier> ListSuppliers(bool areInUse, bool includeAllOption, int contractTypeID)
{
  if (areInUse && includeAllOption)
  {

  }
  else if (areInUse)
  {

  }
  else if (includeAllOption)
  {

  }
}

Although "areInUse" doesn't seem very English friendly, I'm not brilliant with naming. As you can see, logic resides in my data access layer (repository) which isn't friendly. I could define separate functions but as I say, it grows quite quick.

Could anyone recommend a good solution?

NOTE: I use LINQ for entities only, I don't use it to query. Please don't ask, it's a constraint on the system not specified by me. If I had the choice, I'd use LINQ, but I don't unfortunately.

Answer 1

You can implement

IEnumerable<Supplier> GetAllSuppliers() { ... }

end then use LINQ on the returned collection. This will retrieve all suppliers from the database that are then filtered using LINQ.

Assuming you are using LINQ to SQL you can also implement

IQueryable<Supplier> GetAllSuppliers() { ... }

end then use LINQ on the returned collection. This will only retrieve the necessary suppliers from the database when the collection is enumerated. This is very powerful and there are also some limits to the LINQ you can use. However, the biggest problem is that you are able to drill right through your data-access layer and into the database using LINQ.

A query like

var query = from supplier in repository.GetAllSuppliers()
            where suppliers.Name.StartsWith("Foo") select supplier;

will map into SQL similar to this when it is enumerated

SELECT ... WHERE Name LIKE 'Foo%'

Answer 2

Have your method take a Func<Supplier,bool> which can be used in Where clause so that you can pass it in any type of filter than you would like to construct. You can use a PredicateBuilder to construct arbitrarily complex functions based on boolean operations.

public IEnumerable<Supplier> ListSuppliers( Func<Supplier,bool> filter )
{
    return this.DataContext.Suppliers.Where( filter );
}


var filter = PredicateBuilder.False<Supplier>();
filter = filter.Or( s => s.IsInUse ).Or( s => s.ContractTypeID == 3 );

var suppliers = repository.ListSuppliers( filter );