September 15, 2023 #DI API, #Transactions, #Development 7 minute read

Transaction Management in SAP Business One DI API

Proper transaction management is crucial when working with the SAP Business One DI API. This comprehensive guide covers best practices and implementation details for handling transactions effectively.

1. Understanding DI API Transactions

The DI API provides transaction management capabilities to ensure data consistency:

public class DIAPITransactionManager
{
    private readonly SAPbobsCOM.Company _company;

    public DIAPITransactionManager(SAPbobsCOM.Company company)
    {
        _company = company;
    }

    public void BeginTransaction()
    {
        if (_company.InTransaction)
        {
            throw new InvalidOperationException("Transaction already in progress");
        }
        _company.StartTransaction();
    }

    public void CommitTransaction()
    {
        if (!_company.InTransaction)
        {
            throw new InvalidOperationException("No transaction in progress");
        }
        _company.EndTransaction(SAPbobsCOM.BoWfTransOpt.wf_Commit);
    }

    public void RollbackTransaction()
    {
        if (!_company.InTransaction)
        {
            throw new InvalidOperationException("No transaction in progress");
        }
        _company.EndTransaction(SAPbobsCOM.BoWfTransOpt.wf_RollBack);
    }
}

2. Implementing Transaction Patterns

Here's a practical example of implementing transaction patterns:

public class BusinessPartnerManager
{
    private readonly DIAPITransactionManager _transactionManager;
    private readonly SAPbobsCOM.BusinessPartners _bpService;

    public void CreateBusinessPartnerWithContacts(string cardCode, List contacts)
    {
        try
        {
            _transactionManager.BeginTransaction();

            // Create Business Partner
            _bpService.CardCode = cardCode;
            _bpService.CardName = "New Customer";
            _bpService.CardType = SAPbobsCOM.BoCardTypes.cCustomer;
            
            // Add contacts
            foreach (var contact in contacts)
            {
                _bpService.ContactEmployees.Name = contact.Name;
                _bpService.ContactEmployees.Position = contact.Position;
                _bpService.ContactEmployees.Add();
            }

            if (_bpService.Add() != 0)
            {
                string error;
                _company.GetLastError(out int errCode, out error);
                throw new Exception($"Error creating BP: {errCode} - {error}");
            }

            _transactionManager.CommitTransaction();
        }
        catch (Exception ex)
        {
            _transactionManager.RollbackTransaction();
            throw;
        }
    }
}

3. Transaction Scope and Boundaries

Understanding transaction scope is crucial for proper implementation:

• Keep transactions as short as possible
• Only include necessary operations
• Handle nested transaction scenarios
• Consider performance implications

public class TransactionScope : IDisposable
{
    private readonly DIAPITransactionManager _manager;
    private bool _completed = false;

    public TransactionScope(DIAPITransactionManager manager)
    {
        _manager = manager;
        _manager.BeginTransaction();
    }

    public void Complete()
    {
        _completed = true;
    }

    public void Dispose()
    {
        if (_completed)
        {
            _manager.CommitTransaction();
        }
        else
        {
            _manager.RollbackTransaction();
        }
    }
}

4. Error Handling in Transactions

Implement robust error handling for transactions:

public class TransactionErrorHandler
{
    private readonly ILogger _logger;

    public void HandleTransactionError(Exception ex, string transactionContext)
    {
        _logger.LogError($"Transaction Error in {transactionContext}: {ex.Message}");

        if (ex is DuplicateKeyException)
        {
            throw new BusinessException("Record already exists", ex);
        }
        
        if (ex is DeadlockException)
        {
            // Implement retry logic
            RetryTransaction();
        }

        throw new TransactionException("Transaction failed", ex);
    }

    private void RetryTransaction(Action transaction, int maxRetries = 3)
    {
        for (int i = 0; i < maxRetries; i++)
        {
            try
            {
                transaction();
                return;
            }
            catch (Exception ex)
            {
                if (i == maxRetries - 1) throw;
                Thread.Sleep(1000 * (i + 1)); // Exponential backoff
            }
        }
    }
}

5. Best Practices

Follow these best practices for transaction management:

• Always use try-catch blocks with proper rollback
• Implement proper logging for transaction states
• Consider using transaction scopes for automatic cleanup
• Monitor transaction performance
• Handle deadlock scenarios appropriately

Thanks,

Ahmed Aboalia