Partilhar via

ADO.NET e LINQ to SQL

  • Artigo

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

LINQ to SQL and ADO.NET

Ligações

Você pode fornecer uma conexão ADO.NET existente ao criar um LINQ to SQL DataContext. Todas as operações contra o DataContext (incluindo consultas) usam essa conexão fornecida. Se a conexão já estiver aberta, o LINQ to SQL a deixará como está quando você terminar de usá-la.

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 você mesmo usando a Connection propriedade, como no código a seguir:

db.Connection.Close();

db.Connection.Close()

Transações

Você pode fornecer sua DataContext própria transação de banco de dados quando seu aplicativo já tiver iniciado a transação e você quiser que você DataContext esteja envolvido.

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 na memória. Os escopos de transação exigem poucos recursos para serem iniciados. Eles se promovem para transações distribuídas apenas quando há várias conexões dentro do escopo da transação.

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

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

Não é possível usar essa abordagem para todos os bancos de dados. Por exemplo, a conexão SqlClient não pode promover transações do sistema quando ele funciona em um servidor SQL Server 2000. Em vez disso, ele se alista automaticamente para 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 para o banco de dados e converter os resultados da consulta em objetos.

Por exemplo, suponha que os dados da Customer classe estejam 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 das colunas nos resultados tabulares correspondam às propriedades da coluna da sua classe de entidade, o 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

Nota

Os parâmetros são expressos no texto da consulta usando a mesma notação curva usada por Console.WriteLine() e String.Format(). String.Format() Pega a seqüência de caracteres de consulta fornecida e substitui os parâmetros curly-braced por nomes de parâmetros gerados, como @p0, @p1 ..., @p(n).

Consulte também