Poznámka:
Přístup k této stránce vyžaduje autorizaci. Můžete se zkusit přihlásit nebo změnit adresáře.
Přístup k této stránce vyžaduje autorizaci. Můžete zkusit změnit adresáře.
Platí pro: 
.NET Framework .NET Standard
.NET obsahuje transakční rozhraní, ke kterému lze přistupovat prostřednictvím System.Transactions oboru názvů. Tato architektura zveřejňuje transakce způsobem, který je plně integrovaný v .NET, včetně ADO.NET.
Kromě vylepšení programovatelnosti mohou System.Transactions a ADO.NET spolupracovat na koordinaci optimalizací při práci s transakcemi. Propagační transakce je jednoduchá (místní) transakce, která lze automaticky zvýšit na plně distribuovanou transakci podle potřeby.
Zprostředkovatel dat Microsoft SqlClient pro SQL Server podporuje propagační transakce při práci s SQL Serverem. Propagační transakce nevyvolává přidanou režii distribuované transakce, pokud není vyžadována přidaná režie. Propagační transakce jsou automatické a nevyžadují žádný zásah od vývojáře.
Vytváření propagačních transakcí
Zprostředkovatel dat Microsoft SqlClient pro SQL Server poskytuje podporu pro propagační transakce, které jsou zpracovávány prostřednictvím tříd v System.Transactions oboru názvů. Propagační transakce optimalizují distribuované transakce odložením vytvoření distribuované transakce, dokud ji nepotřebujete. Pokud je vyžadován pouze jeden správce prostředků, nedojde k žádné distribuované transakci.
Poznámka:
V částečně důvěryhodném scénáři je DistributedTransactionPermission vyžadován, když je transakce povýšena na distribuovanou transakci.
Scénáře propagačních transakcí
Distribuované transakce obvykle spotřebovávají významné systémové prostředky, které spravuje koordinátor distribuovaných transakcí (MS DTC), který integruje všechny správce prostředků, ke kterým přistupují v transakci. Propagovatelná transakce je speciální forma System.Transactions transakce, která efektivně deleguje práci na jednoduchou transakci SQL Serveru. System.Transactions, Microsoft.Data.SqlClient, a SQL Server koordinují práci zapojenou do zpracování transakce a podle potřeby ji povyšují na plně distribuovanou transakci.
Výhodou použití povýšitelných transakcí je, že když je připojení otevřeno pomocí aktivní TransactionScope transakce a nejsou otevřena žádná další připojení, transakce se potvrdí jako lehká transakce, místo aby bylo nutné nést dodatečnou režii plné distribuované transakce.
Klíčová slova připojovacího řetězce
Vlastnost ConnectionString podporuje klíčové slovo Enlist, které označuje, zda Microsoft.Data.SqlClient bude rozpoznat transakční kontexty a automaticky zařadí připojení do distribuované transakce. Pokud Enlist=trueje připojení automaticky zařazeno do aktuálního kontextu transakce v počátečním vlákně. Pokud Enlist=false, připojení SqlClient nepracuje s distribuovanou transakcí. Výchozí hodnota je Enlist true. Pokud Enlist není zadán v připojovacím řetězci, je připojení automaticky zařazeno do distribuované transakce, pokud je při otevření připojení zjištěna.
Klíčové Transaction Binding slovo v připojovacím SqlConnection řetězci řídí přidružení připojení k zapsané System.Transactions transakci. Je k dispozici také prostřednictvím TransactionBinding vlastnosti SqlConnectionStringBuilder.
Následující tabulka popisuje možné hodnoty.
| Keyword | Description |
|---|---|
| Implicitní zrušení vazby | Výchozí nastavení Připojení se odpojí od transakce po jejím ukončení a přepne zpět do režimu automatického dokončování. |
| Explicitní zrušení vazby | Připojení zůstává připojeno k transakci, dokud transakce nebude uzavřena. Připojení selže, pokud přidružená transakce není aktivní nebo neodpovídá Current. |
Použití TransactionScope
Třída TransactionScope vytvoří transakční blok kódu implicitně zařazením připojení do distribuované transakce. Před opuštěním Complete bloku je nutné volat metodu TransactionScope na konci bloku. Ponechání bloku vyvolá metodu Dispose . Pokud byla vyvolána výjimka, která způsobí, že kód opustí obor, transakce je považována za přerušenou.
Doporučujeme použít using blok, abyste zajistili, že se Dispose volá na TransactionScope objekt při ukončení bloku použití. Selhání potvrzení nebo vrácení čekajících transakcí může výrazně poškodit výkon, protože výchozí časový limit TransactionScope je jedna minuta. Pokud nepoužíváte příkaz using, musíte provést veškerou práci v bloku Try a explicitně zavolat metodu Dispose v bloku Finally.
Pokud dojde k výjimce v TransactionScope, transakce je označena jako nekonzistentní a je opuštěna. Obnova proběhne při vyřazení TransactionScope. Pokud nedojde k žádné výjimce, zúčastněné transakce se potvrdí.
Poznámka:
Třída TransactionScope vytvoří transakci s výchozí hodnotou IsolationLevelSerializable . V závislosti na vaší aplikaci můžete zvážit snížení úrovně izolace, abyste se vyhnuli vysokým kolizím v aplikaci.
Poznámka:
Doporučujeme provádět pouze aktualizace, vkládání a odstraňování v distribuovaných transakcích, protože spotřebovávají významné databázové prostředky. Příkazy Select mohou zbytečně uzamknout databázové prostředky a v některých scénářích možná budete muset pro výběry použít transakce. Jakákoli jiná než databázová práce by měla být provedena mimo rozsah transakce, pokud nezahrnuje jiné správce prostředků, kteří provádějí transakce. I když výjimka v rámci transakce znemožňuje potvrzení transakce, třída TransactionScope nemá žádný mechanismus pro vrácení zpět jakékoli změny, které váš kód provedl mimo rámec samotné transakce. Pokud musíte provést nějakou akci při vrácení transakce, musíte napsat vlastní implementaci rozhraní IEnlistmentNotification a explicitně se zapsat do transakce.
Example
Práce s System.Transactions vyžaduje, abyste měli odkaz na System.Transactions.dll.
Následující funkce ukazuje, jak vytvořit povýšitelnou transakci vzhledem ke dvěma různým instancím SQL Serveru, reprezentovanými dvěma různými SqlConnection objekty, které jsou zabalené do bloku TransactionScope.
Následující kód vytvoří TransactionScope blok příkazem using a otevře první připojení, které ho automaticky zařadí do TransactionScope.
Transakce je původně zařazena jako jednoduchá transakce, nikoli úplná distribuovaná transakce. Druhé připojení je zapsáno pouze v TransactionScope případě, že příkaz v prvním připojení nevyvolá výjimku. Při otevření druhého připojení se transakce automaticky zvýší na úplnou distribuovanou transakci.
Později je Complete vyvolána metoda, která potvrdí transakci pouze v případě, že nebyly vyvolány žádné výjimky. Pokud byla v jakémkoli okamžiku v bloku TransactionScope vyvolána výjimka, Complete nebude volána a distribuovaná transakce bude zrušena, když TransactionScope je ukončen na konci bloku using.
using System;
using System.Transactions;
using Microsoft.Data.SqlClient;
class Program
{
static void Main(string[] args)
{
string connectionString = "Data Source = localhost; Integrated Security = true; Initial Catalog = AdventureWorks";
string commandText1 = "INSERT INTO Production.ScrapReason(Name) VALUES('Wrong size')";
string commandText2 = "INSERT INTO Production.ScrapReason(Name) VALUES('Wrong color')";
int result = CreateTransactionScope(connectionString, connectionString, commandText1, commandText2);
Console.WriteLine("result = " + result);
}
static public int CreateTransactionScope(string connectString1, string connectString2,
string commandText1, string commandText2)
{
// Initialize the return value to zero and create a StringWriter to display results.
int returnValue = 0;
System.IO.StringWriter writer = new System.IO.StringWriter();
// Create the TransactionScope in which to execute the commands, guaranteeing
// that both commands will commit or roll back as a single unit of work.
using (TransactionScope scope = new TransactionScope())
{
using (SqlConnection connection1 = new SqlConnection(connectString1))
{
try
{
// Opening the connection automatically enlists it in the
// TransactionScope as a lightweight transaction.
connection1.Open();
// Create the SqlCommand object and execute the first command.
SqlCommand command1 = new SqlCommand(commandText1, connection1);
returnValue = command1.ExecuteNonQuery();
writer.WriteLine("Rows to be affected by command1: {0}", returnValue);
// if you get here, this means that command1 succeeded. By nesting
// the using block for connection2 inside that of connection1, you
// conserve server and network resources by opening connection2
// only when there is a chance that the transaction can commit.
using (SqlConnection connection2 = new SqlConnection(connectString2))
try
{
// The transaction is promoted to a full distributed
// transaction when connection2 is opened.
connection2.Open();
// Execute the second command in the second database.
returnValue = 0;
SqlCommand command2 = new SqlCommand(commandText2, connection2);
returnValue = command2.ExecuteNonQuery();
writer.WriteLine("Rows to be affected by command2: {0}", returnValue);
}
catch (Exception ex)
{
// Display information that command2 failed.
writer.WriteLine("returnValue for command2: {0}", returnValue);
writer.WriteLine("Exception Message2: {0}", ex.Message);
}
}
catch (Exception ex)
{
// Display information that command1 failed.
writer.WriteLine("returnValue for command1: {0}", returnValue);
writer.WriteLine("Exception Message1: {0}", ex.Message);
}
}
// If an exception has been thrown, Complete will not
// be called and the transaction is rolled back.
scope.Complete();
}
// The returnValue is greater than 0 if the transaction committed.
if (returnValue > 0)
{
writer.WriteLine("Transaction was committed.");
}
else
{
// You could write additional business logic here, notify the caller by
// throwing a TransactionAbortedException, or log the failure.
writer.WriteLine("Transaction rolled back.");
}
// Display messages.
Console.WriteLine(writer.ToString());
return returnValue;
}
}