工作单元设计模式中的事务

我很难理解工作单元的事务概念。我使用的代码如下：工人阶级的单位：

public class UnitOfWork : IDisposable
{
    private readonly DbContext _context;
    private bool disposed = false;
    public UnitOfWork()
    {
        _context = new ResultsContext();
    }
    public IRepository<T> GetRepository<T>() where T : class
    {
        return new Repository<T>(_context);
    }

    public virtual void Dispose(bool disposing)
    {
        if (!disposed)
        {
            if (disposing)
            {
                _context.Dispose();
            }
        }
        disposed = true;
    }
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
    public Study GetStudyWithAll(string studyUid)
    {
        ResultsContext context = _context as ResultsContext;
        return context.Studies.Where(c => c.StudyUid == studyUid)
                              .Include(s => s.Tasks.Select(t => t.Plugins))
                              .Include(s => s.Findings)
                              .Include(s => s.Patient).FirstOrDefault();
    }
    public void SaveChanges()
    {
        if (_context != null)
        {
            bool saved = false;
            do
            {
                try
                {
                    _context.SaveChanges();
                    saved = true;
                }
                catch (DbUpdateException ex)
                {
                    // Get the current entity values and the values in the database 
                    var entry = ex.Entries.Single();
                    //var currentValues = entry.CurrentValues;
                    switch (entry.State)
                    {
                        case System.Data.EntityState.Added:
                            // added on client, non in store - store wins
                            entry.State = System.Data.EntityState.Modified;
                            break;
                        case System.Data.EntityState.Deleted:
                            //deleted on client, modified in store
                            entry.Reload();
                            entry.State = System.Data.EntityState.Deleted;
                            break;
                        case System.Data.EntityState.Modified:
                            DbPropertyValues currentValues = entry.CurrentValues.Clone();
                            //Modified on client, Modified in store
                                entry.Reload();
                                entry.CurrentValues.SetValues(currentValues);
                            break;
                        default:
                            //For good luck
                            entry.Reload();
                            break;
                    }
                }
                catch (System.Data.Entity.Validation.DbEntityValidationException dbEx)
                {
                    Exception raise = dbEx;
                    foreach (var validationErrors in dbEx.EntityValidationErrors)
                    {
                        foreach (var validationError in validationErrors.ValidationErrors)
                        {
                            string message = string.Format("{0}:{1}",
                                validationErrors.Entry.Entity.ToString(),
                                validationError.ErrorMessage);
                            // raise a new exception nesting
                            // the current instance as InnerException
                            raise = new InvalidOperationException(message, raise);
                        }
                    }
                    throw raise;
                }
            } while (!saved);
        }
    }
    public DbContext Context
    {
        get { return _context; }
    }
} 

我使用它的方式：

using (var uow = new UnitOfWork())
{
   //////some stuff///
    uow.SaveChanges();
}

问题是：工作单元上下文是否等于事务，或者我需要添加：

using (TransactionScope transaction = new TransactionScope()) 

在它周围。

我知道saveChanges是用事务包装的，但我不知道的是：整个上下文是否用事务包装。我的意思是，我能确保我读取的数据（而不是保存或更新）在上下文的生命周期中没有更改吗？