Compartilhar via

O ADO.NET e LINQ to SQL

  • Artigo

O LINQ to SQL faz parte da família de tecnologias ADO.NET. É baseada em serviços fornecidos pelo modelo de provedor do 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 to SQL. A ilustração a seguir fornece uma exibição de alto nível de relacionamento.

LINQ to SQL and ADO.NET

conexões

Você pode fornecer uma conexão ADO.NET existente quando cria uma classe LINQ to SQL DataContext. Todas as operações com 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ê concluir seu uso.

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

db.Connection.Close();

db.Connection.Close()

Transactions

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 preferido de fazer transações com o .NET Framework é usar o objeto de TransactionScope. Usando essa abordagem, você pode fazer as transações distribuídas que funcionam através de bases de dados e outros gerentes de recurso de memória residente. 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 bases de dados. Por exemplo, a conexão SqlClient não pode elevar transações do sistema quando trabalha em um servidor SQL Server 2000. Em vez disso, inscreve-se automaticamente para uma transação completa, distribuído consulta sempre que um escopo de transação que está sendo usado.

Comandos SQL diretos

Às vezes você pode encontrar situações onde a capacidade de DataContext de consulte ou enviar alterações insuficientes para a tarefa específica que você deseja executar. Nesteas circunstâncias você pode usar o método de ExecuteQuery para emitir comandos SQL a base de dados e para converter os resultados da consulta a objetos.

Por exemplo, suponha que os dados para a classe de Customer são espalhado sobre duas tabelas (customer1 e customer2). A seguinte consulta retorna uma sequência de objetos Customer :

            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")

Contanto que os nomes de coluna nos resultados tabulares coincidam com propriedades de coluna de sua classe de entidade, o LINQ to SQL criará seus objetos a partir de qualquer consulta SQL.

Parâmetros

O método de ExecuteQuery 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 encaracolado usada por Console.WriteLine() e por 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).

Confira também