C# 4 and .NET 4

630 ❘ ChaPTer 23 system.trAnsActiOns
private Transaction currentTransaction;
internal ResourceManager(Transactional parent, Transaction tx)
{
this.parent = parent;
Value = DeepCopy(parent.liveValue);
currentTransaction = tx;
}
public T1 Value { get; set; }
code snippet CustomResource/ResourceManager.cs
Because the temporary value may change within the transaction, the live value of the wrapper class may
not be changed within the transaction. When creating a copy with some classes, it is possible to invoke
the Clone() method that is defined with the ICloneable interface. However, as the Clone() method is
defined, it allows implementations to create either a shallow or a deep copy. If type T contains reference
types and implements a shallow copy, changing the temporary value would also change the original value.
This would be in conflict with the isolation and consistency features of transactions. Here, a deep
copy is required.
To do a deep copy, the method DeepCopy() serializes and deserializes the object to and from a stream.
Because in C# 4 it is not possible to define a constraint to the type T indicating that serialization is required,
the static constructor of the class Transactional checks if the type is serializable by checking the
property IsSerializable of the Type object.
static ResourceManager()
{
Type t = typeof(T1);
Trace.Assert(t.IsSerializable, "Type " + t.Name +
" is not serializable");
}
private T1 DeepCopy(T1 value)
{
using (MemoryStream stream = new MemoryStream())
{
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(stream, value);
stream.Flush();
stream.Seek(0, SeekOrigin.Begin);
}
}
return (T1)formatter.Deserialize(stream);
The interface IEnlistmentNotification is implemented by the class ResourceManager. This is the
requirement for enlisting with transactions.
The implementation of the Prepare() method just answers by invoking Prepared() with
preparingEnlistment. There should not be a problem assigning the temporary value to the live value, so
the Prepare() method succeeds. With the implementation of the Commit() method, the Commit() method
of the parent is invoked, where the variable liveValue is set to the value of the ResourceManager that
is used within the transaction. The Rollback() method just completes the work and leaves the live value
where it was. With a volatile resource, there is not a lot you can do in the InDoubt() method. Writing a log
entry could be useful:
public void Prepare(PreparingEnlistment preparingEnlistment)
{
preparingEnlistment.Prepared();
}
www.it-ebooks.info