FuncT, bool and ExpressionFuncT, bool

Original answer: Why would you use Expression > rather than Func?

Both do different things, while Func<T, bool> represents a code that will be executed, so much that the code will be converted to intermediate language and possibly executed.

context.Entities.Where((x) => x.Propriedade1 == x.Propriedade2);

In the above case, (x) => x.Propriedade1 == x.Propriedade2 will not be executed, but it contains information of what needs to be done, in which case it will be converted to a query SQL => SELECT * FROM Entities x WHERE x.Propriedade1 == x.Propriedade2

Note that the input and output of both may be the same, but the way they work, the compiled code and what they are intended for is completely different.

Now returning to the example above, if you want to reuse a Func<T, bool> to be used in Where (which expects a Expression<Func<T, bool>> ), you will have to encapsulate the function:

var funcao = new Func<Entity, bool>((x) => x.Propriedade1 == x.Propriedade2);
context.Entities.Where((x) => funcao(x));

Note that in this case, funcao(x) is not executed, but it contains the "instructions" that Expression needs, so it will understand what needs to be done.

Now I'd like to talk a bit about your implementation and what I disagree with it ... the first thing is about this variable repo , it looks like you're using some Repository Pattern implementation together with Entity Framework .

Instead of this, simply use Entity Framework , which in turn already implements Repository Pattern in a much more robust and complete way than you would be able to do it.

Second point, if you really want to isolate snippets of query usage so you can reuse them later, then make use of Extensions.

public class MovimentoTratamento : Tratamento
{
    public string Nr_Nota_Fiscal { get; set; }
    public string Dt_Emissao_Nota_Fiscal { get; set; }
}

public abstract class Tratamento
{
    [Key]
    public int ID{ get; set; }
    public string Cd_Sap_Distribuidor_Matriz { get; set; }
    public string Cd_Sap_Distribuidor_Filial { get; set; }
    public DateTime Dt_Criacao { get; set; }
    public int Id_Log { get; set; }
}

public static class TratamentoExtensions
{
    public static IQueryable<Tratamento> FiltroPadrao(this IQueryable<Tratamento> consulta, FiltroViewModel filtro)
    {
        DateTime inicial, final;
        DateTime.TryParse(filtro.CargaInicial, out inicial);
        DateTime.TryParse(filtro.CargaFinal, out final);

        return consulta.Where(x =>
            ((final == DateTime.MinValue) || (x.Dt_Criacao >= inicial && x.Dt_Criacao <= final.AddDays(1))) &&
            (string.IsNullOrEmpty(filtro.CnpjMatriz) || x.Cd_Sap_Distribuidor_Matriz == filtro.CnpjMatriz) &&
            (string.IsNullOrEmpty(filtro.CnpjFilial) || x.Cd_Sap_Distribuidor_Filial == filtro.CnpjFilial) &&
            (filtro.TipoErro == "0" || x.Cd_Erro == filtro.TipoErro) &&
            ((filtro.StatusSelected == 3) || (filtro.StatusSelected == 1 && x.Id_Log == 0) ||   (filtro.StatusSelected == 2 && x.Id_Log > 0));
    }

    private IQueryable<MovimentoTratamento> FiltroNotaFiscal(this IQueryable<MovimentoTratamento> consulta, FiltroViewModel filtro)
    {
        return consulta.Where(x => (string.IsNullOrEmpty(filtro.NotaFiscal) || x.Nr_Nota_Fiscal == filtro.NotaFiscal));
    }
}

public class TratamentoController
{
    public IQueryable<MovimentoTratamento> Filter(FiltroViewModel filtro)
    {
        using (var context = new MyDbContext())
        {
            return context.MovimentosTratamento.FiltroPadrao(filtro).FiltroNotaFiscal(filtro));
        }
    }
}

The reasons why I do not recommend using an additional Repository Pattern , you can see in the following link When to use Entity Framework with Repository Pattern?

I also recommend reading the following subject: Architecture of Stack Overflow and Stack Exchange