Dela via

ADO.NET och LINQ till SQL

  • Artikel

LINQ till SQL är en del av ADO.NET-serien med tekniker. Den baseras på tjänster som tillhandahålls av ADO.NET-providermodellen. Du kan därför blanda LINQ till SQL-kod med befintliga ADO.NET-program och migrera aktuella ADO.NET lösningar till LINQ till SQL. Följande bild ger en översikt över relationen.

LINQ to SQL and ADO.NET

anslutningar

Du kan ange en befintlig ADO.NET anslutning när du skapar en LINQ till SQL DataContext. Alla åtgärder mot DataContext (inklusive frågor) använder den här angivna anslutningen. Om anslutningen redan är öppen lämnar LINQ till SQL den som när du är klar med den.

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

Du kan alltid komma åt anslutningen och stänga den själv med hjälp Connection av egenskapen, som i följande kod:

db.Connection.Close();

db.Connection.Close()

Transaktioner

Du kan ange din DataContext egen databastransaktion när ditt program redan har initierat transaktionen och du vill att du DataContext ska vara involverad.

Den bästa metoden för att göra transaktioner med .NET Framework är att använda objektet TransactionScope . Med den här metoden kan du göra distribuerade transaktioner som fungerar mellan databaser och andra minnesbaserade resurshanterare. Transaktionsomfång kräver få resurser för att starta. De befordrar sig endast till distribuerade transaktioner när det finns flera anslutningar inom transaktionens omfång.

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

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

Du kan inte använda den här metoden för alla databaser. SqlClient-anslutningen kan till exempel inte höja upp systemtransaktioner när den fungerar mot en SQL Server 2000-server. I stället registreras automatiskt en fullständig, distribuerad transaktion när ett transaktionsomfång används.

Direct SQL-kommandon

Ibland kan du stöta på situationer där möjligheten DataContext att fråga eller skicka ändringar är otillräcklig för den specialiserade uppgift som du vill utföra. Under dessa omständigheter kan du använda ExecuteQuery metoden för att utfärda SQL-kommandon till databasen och konvertera frågeresultatet till objekt.

Anta till exempel att data för Customer klassen är spridda över två tabeller (kund1 och kund2). Följande fråga returnerar en sekvens med Customer objekt:

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

Så länge kolumnnamnen i tabellresultatet matchar kolumnegenskaperna för din entitetsklass skapar LINQ till SQL dina objekt från valfri SQL-fråga.

Parametrar

Metoden ExecuteQuery accepterar parametrar. Följande kod kör en parametriserad fråga:

            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

Kommentar

Parametrar uttrycks i frågetexten med samma kladdiga notation som används av Console.WriteLine() och String.Format(). String.Format() tar frågesträngen som du anger och ersätter de klammerparenteserade parametrarna med genererade parameternamn som @p0, @p1 ..., @p(n).

Se även