Por que Func <T, bool> em vez de Predicado <T>?

Esta é apenas uma pergunta de curiosidade que eu queria saber se alguém tinha uma boa resposta para:

Na Biblioteca de classes do .NET Framework, temos, por exemplo, esses dois métodos:

public static IQueryable<TSource> Where<TSource>(
    this IQueryable<TSource> source,
    Expression<Func<TSource, bool>> predicate
)

public static IEnumerable<TSource> Where<TSource>(
    this IEnumerable<TSource> source,
    Func<TSource, bool> predicate
)

Por que eles usam em Func<TSource, bool>vez de Predicate<TSource>? Parece que o Predicate<TSource>é utilizado apenas por List<T>e Array<T>, enquanto Func<TSource, bool>é utilizado por praticamente todos Queryablee Enumerablemétodos e métodos de extensão ... O que há com isso?

Embora Predicatetenha sido introduzido ao mesmo tempo que List<T>e Array<T>, no .net 2.0, os diferentes Funce Actionvariantes vêm do .net 3.5.

Portanto, esses Funcpredicados são usados ​​principalmente para consistência nos operadores LINQ. A partir do .net 3.5, sobre o uso Func<T>e Action<T>a diretriz declara :

Use os novos tipos LINQ Func<>e, em Expression<>vez de delegados e predicados personalizados

Eu já me perguntei isso antes. Eu gosto do Predicate<T>delegado - é legal e descritivo. No entanto, você precisa considerar as sobrecargas de Where:

Where<T>(IEnumerable<T>, Func<T, bool>)
Where<T>(IEnumerable<T>, Func<T, int, bool>)

Isso permite que você filtre com base no índice da entrada também. Isso é legal e consistente, ao passo que:

Where<T>(IEnumerable<T>, Predicate<T>)
Where<T>(IEnumerable<T>, Func<T, int, bool>)

não seria.

Certamente, o motivo real para usar em Funcvez de um delegado específico é que o C # trata delegados declarados separadamente como tipos totalmente diferentes.

Embora Func<int, bool>e Predicate<int>ambos têm os tipos de argumento e de retorno idênticos, eles não são atribuição compatível. Portanto, se todas as bibliotecas declarassem seu próprio tipo de delegado para cada padrão de delegado, essas bibliotecas não seriam capazes de interoperar a menos que o usuário insira delegados "em ponte" para realizar conversões.

    // declare two delegate types, completely identical but different names:
    public delegate void ExceptionHandler1(Exception x);
    public delegate void ExceptionHandler2(Exception x);

    // a method that is compatible with either of them:
    public static void MyExceptionHandler(Exception x)
    {
        Console.WriteLine(x.Message);
    }

    static void Main(string[] args)
    {
        // can assign any method having the right pattern
        ExceptionHandler1 x1 = MyExceptionHandler; 

        // and yet cannot assign a delegate with identical declaration!
        ExceptionHandler2 x2 = x1; // error at compile time
    }

Ao incentivar todos a usar o Func, a Microsoft espera que isso alivie o problema de tipos de delegados incompatíveis. Os delegados de todos jogam bem juntos, porque eles serão correspondidos com base em seus tipos de parâmetro / retorno.

Não resolve todos os problemas, porque Func(e Action) não podem ter outou refparâmetros, mas esses são menos usados.

Atualização: nos comentários Svish diz:

Ainda assim, mudar um tipo de parâmetro de Func para Predicate e vice-versa não parece fazer nenhuma diferença? Pelo menos ainda compila sem problemas.

Sim, desde que o seu programa atribua apenas métodos aos delegados, como na primeira linha da minha Mainfunção. O compilador silenciosamente gera código para um novo objeto delegado que encaminha para o método. Portanto, na minha Mainfunção, eu poderia mudar x1para ser do tipo ExceptionHandler2sem causar problemas.

No entanto, na segunda linha, tento atribuir o primeiro delegado a outro delegado. Mesmo pensando que o segundo tipo de delegado tem exatamente o mesmo parâmetro e tipos de retorno, o compilador dá erro CS0029: Cannot implicitly convert type 'ExceptionHandler1' to 'ExceptionHandler2'.

Talvez isso torne mais claro:

public static bool IsNegative(int x)
{
    return x < 0;
}

static void Main(string[] args)
{
    Predicate<int> p = IsNegative;
    Func<int, bool> f = IsNegative;

    p = f; // Not allowed
}

Meu método IsNegativeé uma coisa perfeitamente boa para atribuir às variáveis pe f, desde que eu o faça diretamente. Mas não posso atribuir uma dessas variáveis ​​à outra.

O conselho (em 3.5 e acima) é usar o Action<...>e Func<...>- para o "por quê?" - uma vantagem é que "Predicate<T> " só tem sentido se você souber o que "predicado" significa - caso contrário, você precisa procurar no navegador de objetos (etc) para encontrar a assinatura.

Por outro lado, Func<T,bool>segue um padrão padrão; Eu posso dizer imediatamente que esta é uma função que recebe Te retorna umbool - não precisa entender nenhuma terminologia - apenas aplique meu teste de verdade.

Para "predicado", isso pode ter sido bom, mas agradeço a tentativa de padronização. Também permite muita paridade com os métodos relacionados nessa área.