Почему плохо неявно фиксировать единицу работы в методе Dispose ()? - PullRequest
Новая
       32

Почему плохо неявно фиксировать единицу работы в методе Dispose ()?

6 голосов
/ 12 мая 2011

Я написал реализацию UnitOfWork, которая не предоставляет общедоступный метод Commit(). Вместо этого UnitOfWork реализует IDisposable, а фиксация выполняется в методе Dispose(). Я не вижу каких-либо непосредственных проблем с этим, но это кажется неортодоксальным, поэтому я хочу знать, можете ли вы, ребята, указать на какую-то основную причину не делать этого, которую я пропускаю.

Вот пример кода: 

public class DataService
{
    public DataService()
    {
        _db = new MyDataContext();
        _exceptionHandler = new SqlExceptionHandler();
    }
    private readonly MyDataContext _db;
    private readonly SqlExceptionHandler _exceptionHandler;
    public void Add(Product product, Cart cart)
    {
        using(UnitOfWork unitOfWork = new UnitOfWork(_db, ex=>_exceptionHandler.Handle(ex)))
        {
            unitOfWork.Create<CartItem>(new CartItem{CartId = cart.Id, ProductId = product.Id});
            unitOfWork.Update<Product>(x => x.Id == product.Id, product => { product.OrderCount++; });
        }
    }
}


public class UnitOfWork : IDisposable
{
    private readonly DataContext _dataContext;
    private readonly Func<Exception, bool> _handleException;
    private bool _dirty;

    public UnitOfWork(DataContext dataContext, Func<Exception,bool> handleException)
    {
        _dataContext = dataContext;
        _handleException = handleException;
    }

    private Table<T> Table<T>()
        where T: class
    {
        return _dataContext.GetTable<T>();
    }
    private T[] Find<T>(Expression<Func<T,bool>> select)
        where T: class
    {
        return Table<T>().Where(select).ToArray();
    }

    public void Create<T>(T persistentObject)
        where T: class 
    {
        Table<T>().InsertOnSubmit(persistentObject);
        _dirty = true;
    }
    public void Update<T>(Expression<Func<T, bool>> select, Action<T> update)
        where T : class
    {
        var items = Find<T>(select);
        if (items.Length > 0)
        {
            foreach (var target in items) update(target);
            _dirty = true;
        }
    }
    public void Delete<T>(Expression<Func<T, bool>> select)
        where T : class 
    {
        var items = Find<T>(select);
        switch (items.Length)
        {
            case 0: return;
            case 1:
                Table<T>().DeleteOnSubmit(items[0]);
                break;
            default:
                Table<T>().DeleteAllOnSubmit(items);
                break;
        }
        _dirty = true;
    }

    public void Dispose()
    {
        if (_dirty)
        {
            Commit(1);
        }
    }

    private void Commit(int attempt)
    {
            try
            {
                _dataContext.SubmitChanges();
            }
            catch (Exception exception)
            {
                if (attempt == 1 && _handleException != null && _handleException(exception))
                {
                    Commit(2);
                }
                else
                {
                    throw;
                }
            }
    }
}

Ответы [ 2 ]

5 голосов
/ 12 мая 2011

Потому что необработанное исключение совершит транзакцию. И исключение подразумевает, что что-то пошло не так, как планировалось = транзакция не должна быть зафиксирована.

Гораздо лучше набрать Rollback в Dispose, если Commit не вызывали до утилизации.

0 голосов
/ 12 мая 2011

Что если одна из ваших функций, которые вы вызываете в блоке using, выдает исключение? Это может привести к тому, что ваша единица работы окажется в непоследовательном / неполном состоянии, которое вы затем передаете.

...