Problemas conhecidos e considerações no LINQ to EntitiesKnown Issues and Considerations in LINQ to Entities

Esta seção fornece informações sobre problemas conhecidos com consultas LINQ para Entidades.This section provides information about known issues with LINQ to Entities queries.

Consultas LINQ que não podem ser armazenadas em cacheLINQ Queries That cannot be Cached

A partir do .NET Framework 4.5, as consultas LINQ to Entities são automaticamente armazenadas em cache.Starting with .NET Framework 4.5, LINQ to Entities queries are automatically cached. No entanto, as consultas LINQ to Entities que aplicam o operador Enumerable.Contains a coleções na memória não são armazenadas em cache automaticamente.However, LINQ to Entities queries that apply the Enumerable.Contains operator to in-memory collections are not automatically cached. Além disso, não é permitido parametrizar coleções na memória em consultas LINQ compiladas.Also parameterizing in-memory collections in compiled LINQ queries is not allowed.

Informações de ordenação perdidasOrdering Information Lost

Projetar colunas em um tipo anônimo fará com que as informações de pedidos sejam perdidas em algumas consultas que são executadas contra um banco de dados SQL Server 2005 definido para um nível de compatibilidade de "80".Projecting columns into an anonymous type will cause ordering information to be lost in some queries that are executed against a SQL Server 2005 database set to a compatibility level of "80". Isso ocorre quando um nome de coluna na lista order-by corresponde a um nome de coluna no seletor, conforme mostrado no exemplo a seguir:This occurs when a column name in the order-by list matches a column name in the selector, as shown in the following example:

using (AdventureWorksEntities context = new AdventureWorksEntities())
{
    // Ordering information is lost when executed against a SQL Server 2005
    // database running with a compatibility level of "80".
    var results = context.Contacts.SelectMany(c => c.SalesOrderHeaders)
        .OrderBy(c => c.SalesOrderDetails.Count)
        .Select(c => new { c.SalesOrderDetails.Count });

    foreach (var result in results)
        Console.WriteLine(result.Count);
}
Using context As New AdventureWorksEntities()
    ' Ordering information is lost when executed against a SQL Server 2005
    ' database running with a compatibility level of "80".
    Dim results = context.Contacts.SelectMany(Function(c) c.SalesOrderHeaders) _
        .OrderBy(Function(c) c.SalesOrderDetails.Count) _
        .Select(Function(c) New With {c.SalesOrderDetails.Count})

    For Each result In results
        Console.WriteLine(result.Count)
    Next
End Using

Inteiros sem sinal não suportadosUnsigned Integers Not Supported

A especificação de um tipo inteiro não assinado em uma consulta LINQ para Entidades não é suportada porque o Quadro de Entidades não suporta inteiros não assinados.Specifying an unsigned integer type in a LINQ to Entities query is not supported because the Entity Framework does not support unsigned integers. Se você especificar um inteiro ArgumentException não assinado, uma exceção será lançada durante a tradução de expressão de consulta, conforme mostrado no exemplo a seguir.If you specify an unsigned integer, an ArgumentException exception will be thrown during the query expression translation, as shown in the following example. Este exemplo consulta um pedido com a ID 48000.This example queries for an order with ID 48000.

using (AdventureWorksEntities context = new AdventureWorksEntities())
{
    uint s = UInt32.Parse("48000");

    IQueryable<SalesOrderDetail> query = from sale in context.SalesOrderDetails
                                         where sale.SalesOrderID == s
                                         select sale;

    // NotSupportedException exception is thrown here.
    try
    {
        foreach (SalesOrderDetail order in query)
            Console.WriteLine("SalesOrderID: " + order.SalesOrderID);
    }
    catch (NotSupportedException ex)
    {
        Console.WriteLine("Exception: {0}", ex.Message);
    }
}
Using context As New AdventureWorksEntities()
    Dim saleId As UInteger = UInt32.Parse("48000")

    Dim query = _
        From sale In context.SalesOrderDetails _
        Where sale.SalesOrderID = saleId _
        Select sale

    Try
        ' NotSupportedException exception is thrown here.
        For Each order As SalesOrderDetail In query
            Console.WriteLine("SalesOrderID: " & order.SalesOrderID)
        Next
    Catch ex As NotSupportedException
        Console.WriteLine("Exception: " + ex.Message)
    End Try
End Using

Erros de conversão de tiposType Conversion Errors

No Visual Basic, quando uma propriedade é mapeada para uma coluna de tipo bit do SQL Server com um valor igual a 1 usando a função CByte, um SqlException é gerado com uma mensagem de “Erro de estouro aritmético".In Visual Basic, when a property is mapped to a column of SQL Server bit type with a value of 1 using the CByte function, a SqlException is thrown with an "Arithmetic overflow error" message. O exemplo a seguir consulta a coluna Product.MakeFlag no banco de dados de exemplo AdventureWorks e uma exceção é gerada quando os resultados da consulta são iterados sobre.The following example queries the Product.MakeFlag column in the AdventureWorks sample database and an exception is thrown when the query results are iterated over.

Using context As New AdventureWorksEntities()
    Dim productsList = _
        From product In context.Products _
        Select CByte(product.MakeFlag)

    ' Throws an SqlException exception with a "Arithmetic overflow error 
    ' for data type tinyint" message when a value of 1 is iterated over.
    For Each makeFlag In productsList
        Console.WriteLine(makeFlag)
    Next
End Using

Referenciando variáveis não escalares não suportadasReferencing Non-Scalar Variables Not Supported

A referência a variáveis não escalares, como uma entidade, em uma consulta não é suportada.Referencing a non-scalar variables, such as an entity, in a query is not supported. Quando uma consulta desse tipo é executada, é gerada uma exceção NotSupportedException com a mensagem "Não foi possível criar um valor constante de tipo EntityType.When such a query executes, a NotSupportedException exception is thrown with a message that states "Unable to create a constant value of type EntityType. Apenas tipos primitivos ('como Int32, String e GUID') são suportados nesse contexto."Only primitive types ('such as Int32, String, and Guid') are supported in this context."

Observação

A referência a uma coleção de variáveis escalares é suportada.Referencing a collection of scalar variables is supported.

using (AdventureWorksEntities context = new AdventureWorksEntities())
{
    Contact contact = context.Contacts.FirstOrDefault();

    // Referencing a non-scalar closure in a query will
    // throw an exception when the query is executed.
    IQueryable<string> contacts = from c in context.Contacts
        where c == contact
        select c.LastName;

    try
    {
        foreach (string name in contacts)
        {
            Console.WriteLine("Name: ", name);
        }
    }
    catch (NotSupportedException ex)
    {
        Console.WriteLine(ex.Message);
    }
}
Using context As New AdventureWorksEntities()

    Dim contact As Contact = context.Contacts.FirstOrDefault()

    ' Referencing a non-scalar closure in a query will
    ' throw an exception when the query is executed.
    Dim contacts = From c In context.Contacts _
                   Where c.Equals(contact) _
                   Select c.LastName

    Try
        For Each name As String In contacts
            Console.WriteLine("Name: ", name)
        Next

    Catch ex As Exception
        Console.WriteLine(ex.Message)
    End Try

End Using

Pode haver falha em consultas aninhadas com o SQL Server 2000Nested Queries May Fail with SQL Server 2000

Com o SQL Server 2000, pode haver falha em consultas do LINQ to Entities se elas gerarem consultas Transact-SQL aninhadas com três ou mais níveis de profundidade.With SQL Server 2000, LINQ to Entities queries may fail if they produce nested Transact-SQL queries that are three or more levels deep.

Projetando para um tipo anônimoProjecting to an Anonymous Type

Se você definir o caminho da consulta inicial para incluir objetos relacionados usando o método Include no ObjectQuery<T> e, em seguida, usar o LINQ para projetar os objetos retornados para um tipo anônimo, os objetos especificados no método de inclusão não serão incluídos nos resultados da consulta.If you define your initial query path to include related objects by using the Include method on the ObjectQuery<T> and then use LINQ to project the returned objects to an anonymous type, the objects specified in the include method are not included in the query results.

using (AdventureWorksEntities context = new AdventureWorksEntities())
{
    var resultWithoutRelatedObjects =
        context.Contacts.Include("SalesOrderHeaders").Select(c => new { c }).FirstOrDefault();
    if (resultWithoutRelatedObjects.c.SalesOrderHeaders.Count == 0)
    {
        Console.WriteLine("No orders are included.");
    }
}
Using context As New AdventureWorksEntities()
    Dim resultWithoutRelatedObjects = context.Contacts. _
        Include("SalesOrderHeaders"). _
        Select(Function(c) New With {c}).FirstOrDefault()
    If resultWithoutRelatedObjects.c.SalesOrderHeaders.Count = 0 Then
        Console.WriteLine("No orders are included.")
    End If
End Using

Para obter objetos relacionados, não projete tipos retornados para um tipo anônimo.To get related objects, do not project returned types to an anonymous type.

using (AdventureWorksEntities context = new AdventureWorksEntities())
{
    var resultWithRelatedObjects =
        context.Contacts.Include("SalesOrderHeaders").Select(c => c).FirstOrDefault();
    if (resultWithRelatedObjects.SalesOrderHeaders.Count != 0)
    {
        Console.WriteLine("Orders are included.");
    }
}
Using context As New AdventureWorksEntities()
    Dim resultWithRelatedObjects = context.Contacts. _
        Include("SalesOrderHeaders"). _
        Select(Function(c) c).FirstOrDefault()
    If resultWithRelatedObjects.SalesOrderHeaders.Count <> 0 Then
        Console.WriteLine("Orders are included.")
    End If
End Using

Confira tambémSee also