Primeiramente eu tenteiARITHABORT OFF no SSMS ainda é menos de 1 segundo.

Eu uso o EntityFrameWork: 6.1.3 e a camada Sql S1 do Azure (tentarei com a Camada 3 e avisarei se algo mudar.)

Eu uso o EF Profiler para obter sql gerado a partir do linq. Consultei todos os linqs que compartilhei, todos eles têm menos de 1 segundo no SSMS.

Eu tenho 3 milhões de recods na tabela AuditLog. Um cliente com ID 3 possui 170 mil registros e o outro cliente com ID 35 possui 125 registros. Vou minimizar o código.

Modelo do AuditLog:

 public class AuditLog
  {
    public long? CustomerId { get; set; }

    [ForeignKey("CustomerId")]
    public virtual CustomerSummary Customer { get; set; }

    [Required]
    [Index]
     public DateTime CreatedDate { get; set; }
  }

Primeira consulta:

 if (customer != null)
    {
      var customerId = customer.Id;
      var result= Dbset.Where(x => x.CustomerId == customerId).OrderByDescending(x => x.CreatedDate).Skip(0).Take(25).ToList();
    }

se eu tentar com um cliente que tenha 170 mil linhas, isso dará uma exceção de tempo limite. Se eu tentar com um cliente com 125 registros, tudo bem.

Segunda consulta: É o mesmo da primeira, apenas incluo clientes.

if (customer != null)
   {
      var customerId = customer.Id;
      var result= Dbset.Where(x => x.CustomerId == customerId).OrderByDescending(x => x.CreatedDate).Skip(0).Take(25).Include(x => x.Customer).ToList();
    }

O resultado é o oposto da primeira consulta. se eu tentar com um cliente com 170 mil linhas, tudo bem. Se eu tentar com um cliente com 125 registros, isso dará uma exceção de tempo limite.

Terceira consulta: É o mesmo com a primeira consulta, mas eu concordolong? em onde para customerId.

 if (customer != null)
    {
      long? customerId = customer.Id;
      var result= Dbset.Where(x => x.CustomerId == customerId).OrderByDescending(x => x.CreatedDate).Skip(0).Take(25).ToList();
    }

O resultado é o oposto da primeira consulta. se eu tentar com um cliente com 170 mil linhas, tudo bem. Se eu tentar com um cliente com 125 registros, isso dará uma exceção de tempo limite.

Quarta consulta: É o mesmo com a segunda consulta, mas eu concordolong? em onde para customerId.

 if (customer != null)
    {
      long? customerId = customer.Id;
      var result= Dbset.Where(x => x.CustomerId == customerId).OrderByDescending(x => x.CreatedDate).Skip(0).Take(25).Include(x => x.Customer).ToList();
    }

O resultado é o oposto da segunda consulta. se eu tentar com um cliente que tenha 170 mil linhas, isso dará uma exceção de tempo limite. Se eu tentar com um cliente com 125 registros, tudo bem.

Estou realmente confuso. Por que a junção interna ou a alteração do parâmetro de correspondência paralong? estão mudando os resultados? E por que todas essas consultas são executadas em menos de 1 segundo no SSMS e dão erro no ef linq?

Erro:

{System.Data.SqlClient.SqlException (0x80131904): Tempo limite expirado. O período de tempo limite decorrido antes da conclusão da operação ou o servidor não está respondendo. ---> System.ComponentModel.Win32Exception (0x80004005): A operação de espera atingiu o tempo limite System.Data.SqlClient.SqlConnection.OnError (exceção SqlException, Boolean breakConnection, Ação`1 wrapCloseInAction)

Atualização (19/04/2016):

Depois deIvan Stoev sugestão de comentários.

Você já tentou (apenas para testar) usando os códigos 3 e 35 codificados em vez decustomerId variável?

Não recebi nenhum erro e as consultas são mais rápidas do que no SSMS.

Atualização (20/04/2016): O verdadeiro problema éSniffing de Parâmetros. Quando incluí ou alterei o parâmetro para anulável, na verdade criei outras consultas e outros planos de consulta. Criei alguns planos com clientes com 125 registros e outros com clientes com 170 mil registros dessas 4 consultas. É por isso que obtive resultados diferentes.