Compartilhar via

ADO.NET e LINQ to SQL

O LINQ to SQL faz parte da ADO.NET família de tecnologias. Ele se baseia nos serviços fornecidos pelo modelo de provedor de ADO.NET. Portanto, você pode misturar código LINQ to SQL com aplicativos ADO.NET existentes e migrar soluções de ADO.NET atuais para LINQ para SQL. A ilustração a seguir fornece uma visão geral da relação.

LINQ to SQL e ADO.NET

Conexões

Você pode fornecer uma conexão ADO.NET existente ao criar um LINQ para SQL DataContext. Todas as operações em relação às DataContext (incluindo consultas) utilizam a conexão fornecida. Se a conexão já estiver aberta, LINQ to SQL a deixará como está quando você terminar de fazer isso.

string connString = @"Data Source=.\SQLEXPRESS;AttachDbFilename=c:\northwind.mdf;
    Integrated Security=True; Connect Timeout=30; User Instance=True";
SqlConnection nwindConn = new SqlConnection(connString);
nwindConn.Open();

Northwnd interop_db = new Northwnd(nwindConn);

SqlTransaction nwindTxn = nwindConn.BeginTransaction();

try
{
    SqlCommand cmd = new SqlCommand(
        "UPDATE Products SET QuantityPerUnit = 'single item' WHERE ProductID = 3");
    cmd.Connection = nwindConn;
    cmd.Transaction = nwindTxn;
    cmd.ExecuteNonQuery();

    interop_db.Transaction = nwindTxn;

    Product prod1 = interop_db.Products
        .First(p => p.ProductID == 4);
    Product prod2 = interop_db.Products
        .First(p => p.ProductID == 5);
    prod1.UnitsInStock -= 3;
    prod2.UnitsInStock -= 5;

    interop_db.SubmitChanges();

    nwindTxn.Commit();
}
catch (Exception e)
{
    Console.WriteLine(e.Message);
    Console.WriteLine("Error submitting changes... all changes rolled back.");
}

nwindConn.Close();

Dim conString = "Data Source=.\SQLEXPRESS;AttachDbFilename=c:\northwind.mdf; Integrated Security=True;Connect Timeout=30;User Instance=True"
Dim northwindCon = New SqlConnection(conString)
northwindCon.Open()

Dim db = New Northwnd("...")
Dim northwindTransaction = northwindCon.BeginTransaction()

Try
    Dim cmd = New SqlCommand( _
            "UPDATE Products SET QuantityPerUnit = 'single item' " & _
            "WHERE ProductID = 3")
    cmd.Connection = northwindCon
    cmd.Transaction = northwindTransaction
    cmd.ExecuteNonQuery()

    db.Transaction = northwindTransaction

    Dim prod1 = (From prod In db.Products _
                 Where prod.ProductID = 4).First
    Dim prod2 = (From prod In db.Products _
                 Where prod.ProductID = 5).First
    prod1.UnitsInStock -= 3
    prod2.UnitsInStock -= 5

    db.SubmitChanges()

    northwindTransaction.Commit()

Catch e As Exception

    Console.WriteLine(e.Message)
    Console.WriteLine("Error submitting changes... " & _
"all changes rolled back.")
End Try

northwindCon.Close()

Você sempre pode acessar a conexão e fechá-la por conta própria usando a Connection propriedade, como no seguinte código:

db.Connection.Close();

db.Connection.Close()

Transações

Você pode fornecer seu DataContext com sua própria transação de base de dados quando seu aplicativo é iniciado na transação e você deseja que o DataContext a ser empacotado.

O método preferencial de fazer transações com o .NET Framework é usar o TransactionScope objeto. Usando essa abordagem, você pode fazer transações distribuídas que funcionam entre bancos de dados e outros gerenciadores de recursos residentes em memória. Os escopos de transação exigem alguns recursos iniciar. Elevam-se a transações distribuídas somente quando há várias conexões no escopo de transação.

using (TransactionScope ts = new TransactionScope())
{
    db.SubmitChanges();
    ts.Complete();
}

Using ts As New TransactionScope()
    db.SubmitChanges()
    ts.Complete()
End Using

Você não pode usar essa abordagem para todos os bancos de dados. Por exemplo, a conexão SqlClient não pode promover transações do sistema quando funciona em um servidor SQL Server 2000. Em vez disso, ele se inseri automaticamente em uma transação completa e distribuída sempre que vê um escopo de transação sendo usado.

Comandos SQL Diretos

Às vezes, você pode encontrar situações em que a DataContext capacidade de consultar ou enviar alterações é insuficiente para a tarefa especializada que você deseja executar. Nessas circunstâncias, você pode usar o ExecuteQuery método para emitir comandos SQL no banco de dados e converter os resultados da consulta em objetos.

Por exemplo, suponha que os dados da Customer classe sejam distribuídos em duas tabelas (customer1 e customer2). A consulta a seguir retorna uma sequência de Customer objetos:

            IEnumerable<Customer> results = db.ExecuteQuery<Customer>(
    @"select c1.custid as CustomerID, c2.custName as ContactName
        from customer1 as c1, customer2 as c2
        where c1.custid = c2.custid"
);

    Dim results As IEnumerable(Of Customer) = _
db.ExecuteQuery(Of Customer)( _
"SELECT [c1].custID as CustomerID," & _
    "[c2].custName as ContactName" & _
    "FROM customer1 AS [c1], customer2 as [c2]" & _
    "WHERE [c1].custid = [c2].custid")

Desde que os nomes de coluna nos resultados tabulares correspondam às propriedades da coluna da classe de entidade, LINQ to SQL cria seus objetos a partir de qualquer consulta SQL.

Parâmetros

O ExecuteQuery método aceita parâmetros. O código a seguir executa uma consulta parametrizada:

            IEnumerable<Customer> results = db.ExecuteQuery<Customer>(
    "select contactname from customers where city = {0}",
    "London"
);

    Dim results As IEnumerable(Of Customer) = _
db.ExecuteQuery(Of Customer)( _
    "SELECT contactname FROM customers WHERE city = {0}, 'London'")
End Sub

Observação

Os parâmetros são expressos no texto da consulta usando a mesma notação curly usada por Console.WriteLine() e String.Format(). String.Format() leva a cadeia de caracteres de consulta que você fornece e substitui os parâmetros encaracolado- apoiados com nomes de parâmetro gerados como @p0, @p1 …, @p(n).

Consulte também