Question

I am using the repository pattern where I have one repository class per database table. I was wondering how you guys approach queries that only need to return a specific number of columns

For example say I have the following

Item Table (fictional table)

ItemId
Name
PurchaseDate
Description
Price

In my code I create an object with the fields above called Item.cs (currently not using an orm).

If I have multiple scenarios where I need to return

1. ItemId
2. A combination of PurchaseDate and Name
3. ItemId and price

Which would be the best approach?

1. Get all fields from the items table and return an Item object (1 repo query)
2. Create three queries in Repo and return an Item object for each one
3. Create three queries in Repo and return only what is needed?

Now imagine this scenario with a table with over 10 fields.

Personally, I like option one, but I’m not sure if there is a better way to go about this.

Answer 1

I personally use a generic type repository and and have my read AsQueryable()

Here’s the interface.

interface IRepository<T>
{
    void Create(T item);
    IQueryable<T> Retrieve();
    void Update(T item);
    void Delete(T item);
    void SubmitChanges();
}

and here’s the implementation.

public class PersonsRepository : IRepository<Person>
{
    private DataContext dc;

    public PersonsRepository(DataContext dataContext)
    {
        dc = dataContext;
    }

    public void Create(Person Person)
    {
        dc.Persons.Add(Person);
    }

    public IQueryable<Person> Retrieve()
    {
        IQueryable<Person> Person = (from s in dc.Persons
                                       select s);
        return Person.AsQueryable();

    }

    public void Update(Person Person)
    {
        Person _Person = (from s in dc.Persons
                            where s.ID == Person.ID
                            select s).Single();
        {
            _Person.LastLogin = Person.LastLogin;
            _Person.Password = Person.Password;
            _Person.LastUpdate = Person.LastUpdate;
            // Cannot change your username.
        }
    }

    public void Delete(Person Person)
    {
        dc.Persons.Remove(Person);
    }

    public void SubmitChanges()
    {
        dc.SaveChanges();
    }
}

Now if you need to query the repository, you want to do something like this.
_{forgive me, the below code is untested and I’m actually more of a VB guy 🙁
hopefully you get the point}

public class PersonsService
{
    private PersonRepository<Person> personRepository;

    public PersonService()
    {
        personRepository = new PersonRepository<Person>();
    }

    public UsablePerson GetPersonByID(int ID)
    {
        UsablePerson person = (from p in personRepository<Person>.Retrieve
                               where p.ID = ID
                               select new UsablePerson { p.FirstName, 
                                                         p.LastName, 
                                                         p.EmailAddress }).FirstOrDefault();

        return person;
    }
}

For my purposes, I’m using LINQ on this particular project, but this can be adapted to whatever data layer you like… that’s the beauty of a repository layer.

From here I “personally” also have a Service Layer that deals with the nuances of data connection… things like GetPersonByID or GetPeopleSince(DateTime marker). This is where I strip out the information that I don’t need (IE: passwords) and store the remaining information in either a ViewModel or some other POCO.