Can I make my Entity Framework DbSet call my table valued function when selecting?

I wasn't able to get a solution working the way I wanted using a SQL Function, so instead I used this FilteredDbSet which wraps DbSet. All I had to do to implement it was to make the return type on my property in the DbContext a FilteredDbSet and then instantiate it in the constructor with my desired filter. I also made the private constructor in the class below public so I could mock it for unit testing.

This ended up being a very good solution for me because I avoided having to refactor all the existing Linq queries and any future queries will automatically get this behavior.

public class FilteredDbSet<TEntity> : IDbSet<TEntity>, IOrderedQueryable<TEntity>, IListSource where TEntity : class
{
  private readonly DbSet<TEntity> _set;
  private readonly Action<TEntity> _initializeEntity;
  private readonly Expression<Func<TEntity, bool>> _filter;

  public FilteredDbSet(DbContext context, Expression<Func<TEntity, bool>> filter, Action<TEntity> initializeEntity)
    : this(context.Set<TEntity>(), filter, initializeEntity)
  {
  }

  public IQueryable<TEntity> Include(string path)
  {
    return _set.Include(path).Where(_filter).AsQueryable();
  }

  private FilteredDbSet(DbSet<TEntity> set, Expression<Func<TEntity, bool>> filter, Action<TEntity> initializeEntity)
  {
    _set = set;
    _filter = filter;
    _initializeEntity = initializeEntity;
  }

  public IQueryable<TEntity> Unfiltered()
  {
    return _set;
  }

  public TEntity Add(TEntity entity)
  {
    DoInitializeEntity(entity);
    return _set.Add(entity);
  }
  public void AddOrUpdate(TEntity entity)
  {
    DoInitializeEntity(entity);
    _set.AddOrUpdate(entity);
  }
  public TEntity Attach(TEntity entity)
  {
    DoInitializeEntity(entity);
    return _set.Attach(entity);
  }

  public TDerivedEntity Create<TDerivedEntity>() where TDerivedEntity : class, TEntity
  {
    var entity = _set.Create<TDerivedEntity>();
    DoInitializeEntity(entity);
    return entity;
  }

  public TEntity Create()
  {
    var entity = _set.Create();
    DoInitializeEntity(entity);
    return entity;
  }

  public TEntity Find(params object[] keyValues)
  {
    var entity = _set.Find(keyValues);
    if (entity == null)
      return null;


    return entity;
  }

  public TEntity Remove(TEntity entity)
  {
    if (!_set.Local.Contains(entity))
    {
      _set.Attach(entity);
    }
    return _set.Remove(entity);
  }


  public ObservableCollection<TEntity> Local
  {
    get { return _set.Local; }
  }

  IEnumerator<TEntity> IEnumerable<TEntity>.GetEnumerator()
  {
    return _set.Where(_filter).GetEnumerator();
  }

  IEnumerator IEnumerable.GetEnumerator()
  {
    return _set.Where(_filter).GetEnumerator();
  }

  Type IQueryable.ElementType
  {
    get { return typeof(TEntity); }
  }

  Expression IQueryable.Expression
  {
    get
    {
      return _set.Where(_filter).Expression;
    }
  }

  IQueryProvider IQueryable.Provider
  {
    get
    {
      return _set.AsQueryable().Provider;
    }
  }

  bool IListSource.ContainsListCollection
  {
    get { return false; }
  }

  IList IListSource.GetList()
  {
    throw new InvalidOperationException();
  }

  void DoInitializeEntity(TEntity entity)
  {
    if (_initializeEntity != null)
      _initializeEntity(entity);
  }

  public DbSqlQuery<TEntity> SqlQuery(string sql, params object[] parameters)
  {
    return _set.SqlQuery(sql, parameters);
  }
}