public object GetRealObject(StreamingContext context)
{
if (DiagnosticTrace.Verbose)
{
MethodEnteredTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "IObjectReference.GetRealObject");
}
if (this.propagationTokenForDeserialize == null)
{
if (DiagnosticTrace.Critical)
{
InternalErrorTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), System.Transactions.SR.GetString("UnableToDeserializeTransaction"));
}
throw TransactionException.Create(System.Transactions.SR.GetString("TraceSourceOletx"), System.Transactions.SR.GetString("UnableToDeserializeTransactionInternalError"), null);
}
if (null != this.savedLtmPromotedTransaction)
{
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "IObjectReference.GetRealObject");
}
return(this.savedLtmPromotedTransaction);
}
Transaction transactionFromTransmitterPropagationToken = TransactionInterop.GetTransactionFromTransmitterPropagationToken(this.propagationTokenForDeserialize);
this.savedLtmPromotedTransaction = transactionFromTransmitterPropagationToken;
if (DiagnosticTrace.Verbose)
{
TransactionDeserializedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), transactionFromTransmitterPropagationToken.internalTransaction.PromotedTransaction.TransactionTraceId);
}
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "IObjectReference.GetRealObject");
}
return(transactionFromTransmitterPropagationToken);
}
public override Task OnActionExecutingAsync(HttpActionContext actionContext, CancellationToken cancellationToken)
{
return(Task.Factory.StartNew(() =>
{
try
{
if (actionContext.Request.Headers.Contains(TransactionId))
{
var values = actionContext.Request.Headers.GetValues(TransactionId);
if (values != null && values.Any())
{
byte[] transactionToken = Convert.FromBase64String(values.FirstOrDefault());
var transaction = TransactionInterop.GetTransactionFromTransmitterPropagationToken(transactionToken);
var transactionScope = new TransactionScope(transaction);
actionContext.Request.Properties.Add(TransactionId, transactionScope);
}
}
}
catch (Exception ex)
{
_logService.LogMessage(ex);
}
}));
}
public void SyncDTCTransaction(byte[] token)
{
Transaction tran = TransactionInterop.GetTransactionFromTransmitterPropagationToken(token);
using (TransactionScope transactionScope = new TransactionScope(tran))
{
DbContextNet2 dbContextNet2 = new DbContextNet2();
dbContextNet2.School.Add(new School()
{
Name = "dtc"
});
dbContextNet2.SaveChanges();
transactionScope.Complete();
}
// using (var dbContextNet2 = new DbContextNet2())
//using (var command = dbContextNet2.Database.GetDbConnection().CreateCommand())
//{
// command.CommandText = sql;
// dbContextNet2.Database.OpenConnection();
// using (var result = command.ExecuteReader())
// {
// var x = "";
// }
//}
// return true;
// exexute logic with in the distributed trnsaction
}
public static Transaction UnmarshalPropagationToken(byte[] propToken)
{
try
{
return(TransactionInterop.GetTransactionFromTransmitterPropagationToken(propToken));
}
catch (ArgumentException e)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TransactionException(SR.GetString(SR.InvalidPropagationToken), e));
}
}
public static Transaction UnmarshalPropagationToken(byte[] propToken)
{
Transaction transactionFromTransmitterPropagationToken;
try
{
transactionFromTransmitterPropagationToken = TransactionInterop.GetTransactionFromTransmitterPropagationToken(propToken);
}
catch (ArgumentException exception)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TransactionException(System.ServiceModel.SR.GetString("InvalidPropagationToken"), exception));
}
return(transactionFromTransmitterPropagationToken);
}
/// <summary>
/// Retrieve a transaction propagation token, create a transaction scope and promote the current transaction to a distributed transaction.
/// </summary>
/// <param name="actionContext">The action context.</param>
public override void OnActionExecuting(HttpActionContext actionContext)
{
if (actionContext.Request.Headers.Contains(TransactionId))
{
var values = actionContext.Request.Headers.GetValues(TransactionId);
if (values != null && values.Any())
{
byte[] transactionToken = Convert.FromBase64String(values.FirstOrDefault());
var transaction = TransactionInterop.GetTransactionFromTransmitterPropagationToken(transactionToken);
var transactionScope = new TransactionScope(transaction);
actionContext.Request.Properties.Add(TransactionId, transactionScope);
}
}
}
private static void Main()
{
string connString = "data source=.;initial catalog=Test;integrated security=True;persist security info=True";
string tokenFile = @"c:\Temp\token.txt";
Transaction transaction = null;
bool isChild = false;
if (File.Exists(tokenFile))
{
isChild = true;
string tokenString = File.ReadAllText(tokenFile);
byte[] token = Convert.FromBase64String(tokenString);
transaction = TransactionInterop.GetTransactionFromTransmitterPropagationToken(token);
}
using (var parentTxCompleteEvent = new ManualResetEventSlim(!isChild))
{
using (var transactionScope = transaction != null ? new TransactionScope(transaction) : new TransactionScope(TransactionScopeOption.Required, new TimeSpan(0, 15, 0)))
{
var curr = Transaction.Current;
if (!isChild)
{
byte[] transactionBytes = TransactionInterop.GetTransmitterPropagationToken(curr);
string tokenString = Convert.ToBase64String(transactionBytes);
File.WriteAllText(tokenFile, tokenString);
}
else
{
transaction.TransactionCompleted += (sender, e) => parentTxCompleteEvent.Set();
}
using (var conn = new SqlConnection(connString))
{
conn.Open();
using (SqlCommand cmd = conn.CreateCommand())
{
Console.WriteLine("Enter id and value");
cmd.CommandText = "INSERT INTO KeyValue(Id, Value) VALUES (@1, @2)";
cmd.Parameters.Add(new SqlParameter("@1", Console.ReadLine()));
cmd.Parameters.Add(new SqlParameter("@2", Console.ReadLine()));
cmd.ExecuteNonQuery();
}
}
transactionScope.Complete();
Console.WriteLine("Dispose");
Console.ReadLine();
}
parentTxCompleteEvent.Wait();
}
}
/// <summary>
/// Retrieve a transaction propagation token, create a transaction scope and promote the current transaction to a distributed transaction.
/// </summary>
/// <param name="actionContext">The action context.</param>
public override void OnActionExecuting(ActionExecutingContext actionContext)
{
if (actionContext.HttpContext.Request.Headers.ContainsKey(TransactionId))
{
var values = actionContext.HttpContext.Request.Headers[TransactionId];
if (values.Any())
{
//27-05-2021 -> NOT YET Supported on .net 5
//https://github.com/dotnet/runtime/issues/715
//Otherwise
//System.PlatformNotSupportedException: 'This platform does not support distributed transactions.'
byte[] transactionToken = Convert.FromBase64String(values.FirstOrDefault());
var transaction = TransactionInterop.GetTransactionFromTransmitterPropagationToken(transactionToken);
var transactionScope = new TransactionScope(transaction);
actionContext.HttpContext.Items.Add(TransactionId, transactionScope);
}
}
}
/// <summary>
/// Reads out a transaction and a message from a byte buffer.
/// The layout of the buffer should conform with that generated by WriteTransactionMessageBuffer.
/// This method can throw:
/// ArgumentNullException - if 'buffer' is null
/// ArgumentException - if 'count' is less than sizeof(int)
/// TransactionException - if TransactionInterop.GetTransactionFromTransmitterPropagationToken fails
/// InvalidDataException - if the length of the transaction propagation token is negative or greater
/// than the length of the data in the buffer
///
/// </summary>
public static void ReadTransactionMessageBuffer(byte[] buffer, int count, out Transaction transaction, out ArraySegment <byte> message)
{
const byte sizeOfInt = sizeof(int);
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
if (count < sizeOfInt)
{
throw new ArgumentException("'count' is less than size of on int.");
}
MemoryStream mem = new MemoryStream(buffer, 0, count, false, true);
// read the length of the transaction token
byte[] txLengthBytes = new byte[sizeOfInt];
mem.Read(txLengthBytes, 0, sizeOfInt);
int txLength = BitConverter.ToInt32(txLengthBytes, 0);
// check the validity of the length of the transaction propagation token
if (txLength >= count - sizeOfInt || txLength < 0)
{
throw new InvalidDataException("the length of the transaction propagation token read from 'buffer' is invalid");
}
transaction = null;
// read the transaction propagation token and unmarshal the transaction
if (txLength > 0)
{
byte[] txToken = new byte[txLength];
mem.Read(txToken, 0, txToken.Length);
transaction = TransactionInterop.GetTransactionFromTransmitterPropagationToken(txToken);
}
// read the message
int offset = (int)mem.Position;
message = new ArraySegment <byte>(mem.GetBuffer(), offset, count - offset);
}
public Transaction Enlist(byte[] token)
{
return(Enlist(TransactionInterop.GetTransactionFromTransmitterPropagationToken(token)));
}
public void Enlist(ITransactionExecutionEnvironment transactionExecutionEnvironment, byte[] transactionToken)
{
var tx = TransactionInterop.GetTransactionFromTransmitterPropagationToken(transactionToken);
new Neo4jTransationSinglePhaseNotification(transactionExecutionEnvironment).Enlist(tx);
}