在交易中运行C＃代码

Question

I called three methods on button click in asp.net

1. The First Method is to save a text file on the application
2. The Second Method is to create and save PdF file.
3. The Third Method is to send email in asp.net

I want that , If any of the above method has any error occured, then all the methods that are prevsouly called should be rollbacked.

How this is possible.??

Answer 1

Whether or not the operation succeeds, you should always be cleaning up files you create. If you can bypass the file system, and use a MemoryStream to store the data and include it in the email, that would of course both solve your problem and be alot faster.

As mentioned by others, there is no magic method to automatically rollback whatever you created since you clicked that button - you'll have to think of a solution yourself.

Most likely not the best solution, but a simple one, is to create a List<string> containing the files you have successfully written, and in the catch you simply delete all files from that list.

There are tons of other solutions, like a TemporaryFile class that deletes files in its Dispose() method. Give it a go and ask again when you run into issues with your attempt.

Answer 2

In such simpler procedure, you do not need transaction as simple Try/Catch/Finally should do the job.

FileInfo localFile;
FileInfo pdfFile;

try{
    SaveTextFile(localFile);
    SavePDFFile(pdfFile);

    SendEmail();
}catch{
   // something went wrong...
   // you can remove extra try catch
   // but you might get security related
   // exceptions
   try{
      if(localFile.Exists) localFile.Delete();
      if(pdfFile.Exists) pdfFile.Delete();
   }catch{}
}

Here is detailed Transaction Implementation.

This is little long process, but here is a simple implementation (single threaded approach with no locking etc). Remember this is simplest form of transaction with no double locking, no multi version concurrency.

using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required))
{

    FileInfo localFile = new FileInfo("localFile.txt");
    FileInfo pdfFile = new FileInfo("localFile.pdf");

    SimpleTransaction.EnlistTransaction(

        // prepare
        () =>
        {
            CreateTextFile(localFile);
            CreatePDFFile(pdfFile);

            // prepare mail should throw an error
            // if something is missing as sending email
            // is network operation, it cannot be rolled back
            // so email should be sent in commit
            PrepareMail();
        },

        // commit
        () =>
        {
            SendEmail();
        },

        // rollback
        () =>
        {
            try
            {
                if (localFile.Exists)
                    localFile.Delete();
                if (pdfFile.Exists)
                    pdfFile.Delete();
            }
            catch { }
        },

        // in doubt...
        () => { }
    );

}

public class SimpleTransaction : IEnlistmentNotification
{

    public static void EnlistTransaction(Action prepare, Action commit, Action rollback, Action inDoubt)
    {

        var st = new SimpleTransaction(prepare, commit, rollback, inDoubt);
        Transaction.Current.EnlistVolatile(st, EnlistmentOptions.None);

    }


    Action CommitAction;
    Action PrepareAction;
    Action RollbackAction;
    Action InDoubtAction;

    private SimpleTransaction(Action prepare, Action commit, Action rollback, Action inDoubt)
    {
        this.CommitAction = commit;
        this.PrepareAction = prepare;
        this.RollbackAction = rollback;
        this.InDoubtAction = inDoubt  ?? (Action)(() => {});
    }

    public void Prepare(PreparingEnlistment preparingEnlistment)
    {
        try
        {
            PrepareAction();
            preparingEnlistment.Prepared();
        }
        catch
        {
            preparingEnlistment.ForceRollback();
        }

    }

    public void Commit(Enlistment enlistment)
    {
        CommitAction();
        enlistment.Done();
    }

    public void Rollback(Enlistment enlistment)
    {
        RollbackAction();
        enlistment.Done();
    }

    public void InDoubt(Enlistment enlistment)
    {
        InDoubtAction();
        enlistment.Done();
    }
}

The reason this is different from Try Catch is that some other code can rollback transaction instead of raising exception.

Answer 3

Here's another take for achieving what the OP wanted using IEnlistmentNotification . But instead of writing all the operation (save text, save pdf, and send email) in one implementation class, this one use separate IEnlistmentNotification implementation and support for rollback in case of email sending operation failed.

var textPath = "somefile.txt";
var pdfPath = "somefile.pdf";

try {
  using (var scope = new TransactionScope()) {
    var textFileSave = new TextFileSave(textPath);
    var pdfFileSave = new PDFFileSave(pdfPath);

    Transaction.Current.TransactionCompleted += (sender, eventArgs) => {
      try {
        var sendEmail = new SendEmail();
        sendEmail.Send();
      }
      catch (Exception ex) {
        // Console.WriteLine(ex);
        textFileSave.CleanUp();
        pdfFileSave.CleanUp();
      }
    };

    Transaction.Current.EnlistVolatile(textFileSave, EnlistmentOptions.None);
    Transaction.Current.EnlistVolatile(pdfFileSave, EnlistmentOptions.None);

    scope.Complete();
  }
}
catch (Exception ex) {
  // Console.WriteLine(ex);
}
catch {
  // Console.WriteLine("Cannot complete transaction");
}

Here's the implementation details:

SendEmail

public class SendEmail {
  public void Send() {
    // uncomment to simulate error in sending email
    // throw new Exception();

    // write email sending operation here
    // Console.WriteLine("Email Sent");
  }
}

TextFileSave

public class TextFileSave : AbstractFileSave {
   public TextFileSave(string filePath) : base(filePath) { }

   protected override bool OnSaveFile(string filePath) {        
     // write save text file operation here
     File.WriteAllText(filePath, "Some TXT contents");                

     return File.Exists(filePath);
   }
}

PDFFileSave

public class PDFFileSave : AbstractFileSave {
  public PDFFileSave(string filePath) : base(filePath) {}

  protected override bool OnSaveFile(string filePath) {
    // for simulating a long running process
    // Thread.Sleep(5000);

    // write save pdf file operation here
    File.WriteAllText(filePath, "Some PDF contents");

    // try returning false instead to simulate an error in saving file
    // return false;
    return File.Exists(filePath);
  }
}

AbstractFileSave

public abstract class AbstractFileSave : IEnlistmentNotification {
  protected AbstractFileSave(string filePath) {
    FilePath = filePath;
  }

  public string FilePath { get; private set; }

  public void Prepare(PreparingEnlistment preparingEnlistment) {
    try {
      var success = OnSaveFile(FilePath);
      if (success) {
        // Console.WriteLine("[Prepared] {0}", FilePath);
        preparingEnlistment.Prepared();
      }
      else {
        throw new Exception("Error saving file");
      }
    }
    catch (Exception ex) {
      // we vote to rollback, so clean-up must be done manually here
      OnDeleteFile(FilePath);
      preparingEnlistment.ForceRollback(ex);
    }
  }

  public void Commit(Enlistment enlistment) {
    // Console.WriteLine("[Commit] {0}", FilePath);
    enlistment.Done();
  }

  public void Rollback(Enlistment enlistment) {
    // Console.WriteLine("[Rollback] {0}", FilePath);
    OnDeleteFile(FilePath);
    enlistment.Done();
  }

  public void InDoubt(Enlistment enlistment) {
    // in doubt operation here
    enlistment.Done();
  }

  // for manual clean up
  public void CleanUp() {
    // Console.WriteLine("[Manual CleanUp] {0}", FilePath);
    OnDeleteFile(FilePath);
  }

  protected abstract bool OnSaveFile(string filePath);

  protected virtual void OnDeleteFile(string filePath) {
    if (File.Exists(FilePath)) {
      File.Delete(FilePath);
    }
  }
}

One thing worth mentioning about IEnlistmentNotification implementation is: if a resource called/ voted a ForceRollback() within the Prepare() method, the Rollback() method for that resource will not be triggered. So any cleanup that should have happen in Rollback() may need to be manually called in Prepare() .