Problemi noti e considerazioni in LINQ to EntitiesKnown Issues and Considerations in LINQ to Entities

Contenuto della sezione vengono fornite informazioni sui problemi noti relativi alle query LINQ to EntitiesLINQ to Entities.This section provides information about known issues with LINQ to EntitiesLINQ to Entities queries.

Query LINQ che non possono essere memorizzate nella cacheLINQ Queries That cannot be Cached

A partire da .NET Framework 4.5, le query LINQ to Entities vengono memorizzate nella cache automaticamente.Starting with .NET Framework 4.5, LINQ to Entities queries are automatically cached. Tuttavia, le query LINQ to Entities che applicano l'operatore Enumerable.Contains alle raccolte in memoria non vengono memorizzate automaticamente nella cache.However, LINQ to Entities queries that apply the Enumerable.Contains operator to in-memory collections are not automatically cached. Inoltre, la parametrizzazione delle raccolte in memoria nelle query LINQ compilate non è consentita.Also parameterizing in-memory collections in compiled LINQ queries is not allowed.

Perdita delle informazioni di ordinamentoOrdering Information Lost

La proiezione di colonne in un tipo anonimo comporta la perdita delle informazioni di ordinamento in alcune query eseguite su un database di SQL Server 2005SQL Server 2005 con un livello di compatibilità impostato su "80".Projecting columns into an anonymous type will cause ordering information to be lost in some queries that are executed against a SQL Server 2005SQL Server 2005 database set to a compatibility level of "80". Questo avviene quando un nome di colonna nell'elenco di ordinamento corrisponde a un nome di colonna nel selettore, come illustrato nell'esempio seguente: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

Mancato supporto degli Unsigned IntegerUnsigned Integers Not Supported

Non è possibile specificare un tipo Unsigned Integer in una query LINQ to EntitiesLINQ to Entities in quanto in Entity FrameworkEntity Framework non sono supportati gli integer senza segno.Specifying an unsigned integer type in a LINQ to EntitiesLINQ to Entities query is not supported because the Entity FrameworkEntity Framework does not support unsigned integers. Se si specifica un intero senza segno, un ArgumentException verrà generata l'eccezione durante la conversione di espressione di query, come illustrato nell'esempio seguente.If you specify an unsigned integer, an ArgumentException exception will be thrown during the query expression translation, as shown in the following example. In questo esempio viene eseguita una query per un ordine con 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

Errori di conversione dei tipiType Conversion Errors

In Visual Basic quando una proprietà è mappata a una colonna di tipo bit SQL Server con un valore 1 usando la funzione CByte, viene generato un evento SqlException con un messaggio di errore di overflow aritmetico.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. Nell'esempio seguente viene eseguita una query sulla colonna Product.MakeFlag nel database di esempio AdventureWorks e viene generata un'eccezione quando viene eseguita un'iterazione dei risultati della query.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

Riferimento a variabili non scalari non supportatoReferencing Non-Scalar Variables Not Supported

Il riferimento in una query a variabili non scalari, ad esempio un'entità, non è supportato.Referencing a non-scalar variables, such as an entity, in a query is not supported. Durante l'esecuzione di una query di questo tipo, viene generata un'eccezione NotSupportedException, seguita dal messaggio "Impossibile creare un valore di costante di 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. In questo contesto solo supportati solo i tipi primitivi ('ad esempio Int32, String e GUID')".Only primitive types ('such as Int32, String, and Guid') are supported in this context."

Nota

Il riferimento a una raccolta di variabili scalari supportato.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

Errori di esecuzione di query annidate con SQL Server 2000Nested Queries May Fail with SQL Server 2000

Con SQL Server 2000, è possibile che le query LINQ to Entities non vengano eseguite correttamente se producono query Transact-SQL annidate con tre o più livelli di profondità.With SQL Server 2000, LINQ to Entities queries may fail if they produce nested Transact-SQL queries that are three or more levels deep.

Proiezione in un tipo anonimoProjecting to an Anonymous Type

Se si definisce il percorso iniziale della query per includere gli oggetti correlati tramite il metodo Include su ObjectQuery<T> e si usa quindi LINQ per proiettare gli oggetti restituiti in un tipo anonimo, gli oggetti specificati nel metodo di inclusione non vengono inclusi nei risultati della query.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

Per ottenere oggetti correlati, non proiettare i tipi restituiti in un tipo anonimo.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

Vedere ancheSee Also

LINQ to EntitiesLINQ to Entities