Generic repository pattern
I have created generic repositories many times and what I found was that you're going to need to create interfaces for each entity typed repository.
So IUserRepository that implements IGenericRepository&lt;User&gt;, this way you'll be able to

Inject the repository easier with Inversion Of Control
Create extra methods for each entity type as and when
Test your controller easier

Update
I realise this update comes a long time after the question, but time has past and experience has been gained.
You don't necessarily need a new interface for entity type. IoC containers can inject a specific implementation based on the generic parameter of the IGenericRepositoy interface. You will need an interface however for each implementation that has specific methods for that type, such as GetExpiredProducts() as mentioned in the initial question.
You could also remove the generic parameter from the interface and move the where clause to each method:
public interface IGenericRepository : IDisposable
{
    IEnumerable&lt;T&gt; SelectAll() where T : class;
    T SelectByID(object id) where T : class;
    void Insert(T obj) where T : class;
    void Update(T obj) where T : class;
    void Delete(object id);
    void Save();
}

then implement a GenericRepository class:
public class GenericRepository : IGenericRepository
{
    public GenericRepository()
    {
        blah...  
    }
    public GenericRepository(ModelDBEntities dataContext)
    {
        blah...  
    }

    public IEnumerable&lt;T&gt; SelectAll() where T : class
    {
        blah...  
    }
    public T SelectByID(object argId) where T : class
    {
        blah...  
    }
    public void Insert(T obj) where T : class
    {
       blah...  
    }
    public void Update(T obj) where T : class
    {
        blah...            
    }
    public void Delete(object argId)
    {
        blah...  
    }
    public void Save()
    {
        blah...  
    }
}

this would mean that any implementation of a type specific repository could just inherit this saving you some work
public interface IUserRepository : IGenericRepository
{
    int CountUsers();
}

public class UserRepository : GenericRepository, IUserRepository
{
    public UserRepository()
    {
        blah...  
    }
    public UserRepository(ModelDBEntities dataContext)
        : base(dataContext)
    {
        blah...  
    }
    
    public int CountUsers()
    {
        blah...
    }
}

You can then decide on what you want to inject into your controller, if you just want the base CRUD methods then you will only need to pass in the implementation of IGenericRepository and use for several types.