C# IUnitOfWork.BeginTransaction方法代码示例

        public object BeforeCall(RouteContext ctx)
        {
            _uow = DependencyContainer.Current.Resolve<IUnitOfWork>();

            if (ctx.Method.HttpMethod != HttpMethod.Get)
            {
                _uow.BeginTransaction();
            }
            return null;
        }

 public void Start()
 {
     if (!UnitOfWork.IsStarted ||
         transactionMode != TransactionMode.Requires ||
         !UnitOfWork.Current.IsInActiveTransaction)
     {
         unitOfWork = UnitOfWork.Start();
         rhinoTransaction = unitOfWork.BeginTransaction();
     }
 }

 /// <summary>
 /// Overloaded Constructor.
 /// Creates a new instance of the <see cref="UnitOfWorkScopeTransaction"/> that takes in a 
 /// <see cref="IUnitOfWorkFactory"/> instance that is responsible for creating instances of <see cref="IUnitOfWork"/> and
 /// a <see cref="IDbConnection"/> that is used by the instance to connect to the data store.
 /// </summary>
 /// <param name="unitOfWorkFactory">The <see cref="IUnitOfWorkFactory"/> implementation that is responsible
 /// for creating instances of <see cref="IUnitOfWork"/> instances.</param>
 /// <param name="isolationLevel">One of the values of <see cref="IsolationLevel"/> that specifies the transaction
 /// isolation level of the <see cref="UnitOfWorkScopeTransaction"/> instance.</param>
 public UnitOfWorkScopeTransaction(IUnitOfWorkFactory unitOfWorkFactory, IsolationLevel isolationLevel)
 {
     Guard.Against<ArgumentNullException>(unitOfWorkFactory == null,
                                          "A valid non-null instance that implements the IUnitOfWorkFactory is required.");
     _transactionID = new Guid();
     _transactionRolledback = false;
     _disposed = false;
     _unitOfWork = unitOfWorkFactory.Create();
     _runningTransaction = _unitOfWork.BeginTransaction(isolationLevel);
     _isolationLevel = isolationLevel;
     _attachedScopes = new Stack<UnitOfWorkScope>();
 }

        private static void RemoveUsersFromRoles(IRepository repository, IUnitOfWork unitOfWork, string[] userNames, string[] roleNames)
        {
            unitOfWork.BeginTransaction();

            var distinctRoleNames = roleNames.Distinct().ToList();
            var futureQueries = new List<IEnumerable<Models.Role>>();

            foreach (var userName in userNames.Distinct())
            {
                var futureQuery = repository
                    .AsQueryable<Models.UserRole>(userRole => userRole.User.UserName == userName
                        && distinctRoleNames.Contains(userRole.Role.Name))
                    .Select(userRole => new Models.Role
                        {
                            Id = userRole.Id,
                            Version = userRole.Version
                        })
                    .ToFuture();
                
                futureQueries.Add(futureQuery);
            }

            futureQueries.ForEach(futureQuery => 
                futureQuery.ToList().ForEach(role => 
                    repository.Delete<Models.UserRole>(role.Id, role.Version)));

            unitOfWork.Commit();
        }

        private static void AddUsersToRoles(IRepository repository, IUnitOfWork unitOfWork, string[] userNames, string[] roleNames)
        {
            unitOfWork.BeginTransaction();

            // Get roles future query
            var distinctRoleNames = roleNames.Distinct().ToArray();
            var roleIdsQuery = repository
                .AsQueryable<Models.Role>(role => distinctRoleNames.Contains(role.Name))
                .Select(role => new
                                    {
                                        Id = role.Id,
                                        Name = role.Name
                                    })
                .ToFuture();

            // Get users future query
            var distinctUserNames = userNames.Distinct().ToArray();
            var userIdsQuery = repository
                .AsQueryable<Models.User>(user => distinctUserNames.Contains(user.UserName))
                .Select(user => new
                                    {
                                        Id = user.Id,
                                        Name = user.UserName
                                    })
                .ToFuture();

            // Get already assigned roles
            var alreadyAssigned = repository
                .AsQueryable<Models.UserRole>(userRole => distinctUserNames.Contains(userRole.User.UserName))
                .Select(userRole => new
                                        {
                                            UserId = userRole.User.Id,
                                            RoleId = userRole.Role.Id
                                        })
                .ToFuture()
                .ToList();

            // Validate roles
            var roles = roleIdsQuery.ToList();
            roleNames
                .Where(roleName => roles.All(role => roleName != role.Name))
                .ForEach(roleName =>
                    { throw new ProviderException(string.Format("Role {0} does not exist.", roleName)); });

            // Validate users
            var users = userIdsQuery.ToList();
            userNames
                .Where(userName => users.All(user => userName != user.Name))
                .ForEach(userName =>
                    { throw new ProviderException(string.Format("User {0} does not exist.", userName)); });

            // Add users to roles
            roles
                .ForEach(role => users
                    .ForEach(user =>
                        {
                            if (!alreadyAssigned.Any(a => a.UserId == user.Id && a.RoleId == role.Id))
                            {
                                var userRole = new Models.UserRole
                                                   {
                                                       User = repository.AsProxy<Models.User>(user.Id),
                                                       Role = repository.AsProxy<Models.Role>(role.Id), 
                                                   };
                                repository.Save(userRole);
                            }
                        }));

            unitOfWork.Commit();
        }

        private static bool DeleteRole(IRoleService roleService, IUnitOfWork unitOfWork, string roleName, bool throwOnPopulatedRole)
        {
            unitOfWork.BeginTransaction();
            var role = roleService.DeleteRole(roleName, throwOnPopulatedRole);
            unitOfWork.Commit();

            Events.UserEvents.Instance.OnRoleDeleted(role);

            return true;
        }

 private static void CreateRole(IRoleService roleService, IUnitOfWork unitOfWork, string roleName)
 {
     unitOfWork.BeginTransaction();
     roleService.CreateRole(roleName);
     unitOfWork.Commit();
 }

        private static bool ChangePassword(IAuthenticationService authenticationService, IUnitOfWork unitOfWork, string username, string oldPassword, string newPassword)
        {
            unitOfWork.BeginTransaction();
            var success = authenticationService.ChangePassword(username, oldPassword, newPassword);
            unitOfWork.Commit();

            return success;
        }

 public void BeginTransaction()
 {
     _uow = ServiceLocator.Current.GetInstance<IUnitOfWork>();
     _uow.BeginTransaction();
 }

 private void OpenSession(object sender, EventArgs e)
 {
     _session = Locator.GetComponet<IUnitOfWork>();
     _session.BeginTransaction();
 }

 public void BeginTransaction()
 {
     _unitOfWork = ObjectFactory.GetInstance<IUnitOfWork>();
     _unitOfWork.BeginTransaction();
 }