Consulte através das relações

As referências a outros objetos ou coleções de outros objetos em suas definições de classe correspondem diretamente a relações de chave estrangeira no banco de dados. Você pode usar essas relações ao consultar usando a notação de ponto para acessar as propriedades da relação e navegar de um objeto para outro. Essas operações de acesso se traduzem em junções mais complexas ou subconsultas correlacionadas no SQL equivalente.

Por exemplo, a consulta a seguir navega de pedidos para clientes como uma forma de restringir os resultados apenas a esses pedidos para clientes localizados em Londres.

        Northwnd db = new Northwnd(@"northwnd.mdf");

        IQueryable<Order> londonOrderQuery =
from ord in db.Orders
where ord.Customer.City == "London"
select ord;

    Dim db As New Northwnd("c:\northwnd.mdf")
    Dim londonOrderQuery = _
From ord In db.Orders _
Where ord.Customer.City = "London" _
Select ord

Se as propriedades de relação não existirem, você teria que gravá-las manualmente como junções, assim como faria em uma consulta SQL, como no seguinte código:

        Northwnd db = new Northwnd(@"northwnd.mdf");
        IQueryable<Order> londonOrderQuery =
from cust in db.Customers
join ord in db.Orders on cust.CustomerID equals ord.CustomerID
where cust.City == "London"
select ord;

    Dim db As New Northwnd("c:\northwnd.mdf")
    Dim londOrderQuery = _
From cust In db.Customers _
Join ord In db.Orders On cust.CustomerID Equals ord.CustomerID _
Select ord

Você pode usar a propriedade de relação para definir essa relação específica uma vez. Você pode então usar a sintaxe de ponto, que é mais conveniente. Mas as propriedades de relação têm maior importância porque os modelos de objeto específicos do domínio geralmente são definidos como hierarquias ou grafos. Os objetos nos quais você programa têm referências a outros objetos. É apenas uma coincidência felizmente que as relações de objeto-à- objeto correspondem às relações estrangeiro-chave- estilo em bases de dados. Acesso da propriedade em fornece uma maneira conveniente de escrever join.

Em relação a isso, as propriedades de relação são mais importantes no lado dos resultados de uma consulta do que como parte da própria consulta. Depois que a consulta tiver recuperado dados sobre um cliente específico, a definição de classe indica que os clientes têm pedidos. Ou você espera é a propriedade de Orders de um cliente específico ser uma coleção que é preenchida com todos os pedidos do cliente. Na verdade, esse é o contrato que você declarou definindo as classes dessa maneira. Você espera consulte existem os pedidos mesmo se a consulta não solicitou pedidos. Você espera que seu modelo de objeto mantenha uma ilusão de que ele é uma extensão na memória do banco de dados com objetos relacionados imediatamente disponíveis.

Agora que você tem relações, você pode escrever consultas referindo-se às propriedades de relação definidas em suas classes. Essas referências de relação correspondem a relações de chave estrangeira no banco de dados. As operações que usam essas relações se traduzem em junções mais complexas no SQL equivalente. Desde que você tenha definido uma relação (usando o AssociationAttribute atributo), não será necessário codificar uma junção explícita no LINQ ao SQL.

Para ajudar a manter essa ilusão, o LINQ to SQL implementa uma técnica chamada carregamento adiado. Para obter mais informações, consulte Deferred versus Immediate Loading.

Considere a seguinte consulta SQL para projetar uma lista de CustomerID-OrderID pares:

SELECT t0.CustomerID, t1.OrderID  
FROM   Customers AS t0 INNER JOIN  
          Orders AS t1 ON t0.CustomerID = t1.CustomerID  
WHERE  (t0.City = @p0)  

Para obter os mesmos resultados usando LINQ to SQL, você usa a referência de propriedade Orders já que existe na classe Customer. A Orders referência fornece as informações necessárias para executar a consulta e projetar os CustomerID-OrderID pares, como no seguinte código:

        Northwnd db = new Northwnd(@"northwnd.mdf");
        var idQuery =
from cust in db.Customers
from ord in cust.Orders
where cust.City == "London"
select new { cust.CustomerID, ord.OrderID };

    Dim db As New Northwnd("c:\northwnd.mdf")
    Dim idQuery = _
From cust In db.Customers, ord In cust.Orders _
Where cust.City = "London" _
Select cust.CustomerID, ord.OrderID

Você também pode fazer o inverso. Ou seja, você pode consultar Orders e usar sua Customer referência de relação para acessar informações sobre o objeto associado Customer . O código a seguir projeta os mesmos CustomerID-OrderID pares de antes, mas desta vez consultando Orders em vez de Customers.

        Northwnd db = new Northwnd(@"northwnd.mdf");
        var idQuery =
from ord in db.Orders
where ord.Customer.City == "London"
select new { ord.Customer.CustomerID, ord.OrderID };

    Dim db As New Northwnd("c:\northwnd.mdf")
    Dim idQuery = _
From ord In db.Orders _
Where ord.Customer.City = "London" _
Select ord.CustomerID, ord.OrderID

Consulte também

• Conceitos de consulta