public Task <bool> IsValidUser(string provider, string providerKey, string providerAccessCode) { using (IDisposableDependencyObjectWrapper <IExternalAuthProviderApi> providerApi = CreateProviderApi(provider)) { return(providerApi.Object.IsValidUser(providerKey, providerAccessCode)); } }
/// <summary> /// Create a new unit of work scope. /// </summary> internal UnitOfWorkScope(bool isTransactional, IIocResolver iocResolver) { //There is already a uow, do nothing if (Current != null) { return; } //this scope started the uow _isStartedByThisScope = true; _unitOfWorkWrapper = iocResolver.ResolveAsDisposable <IUnitOfWork>(); try { Current = _unitOfWorkWrapper.Object; Current.Initialize(isTransactional); Current.Begin(); } catch { Current = null; throw; } }
/// <summary> /// This method can be used to resolve and release an object automatically. /// You can use the object in <see cref="doAction" />. /// </summary> /// <typeparam name="T">Type of the object to get</typeparam> /// <param name="iocManager">IIocManager object</param> /// <param name="doAction"></param> public static void ResolveUsing <T>(this IIocManager iocManager, Action <T> doAction) { using (IDisposableDependencyObjectWrapper <T> wrapper = iocManager.ResolveAsDisposable <T>()) { doAction(wrapper.Object); } }
/// <summary> /// This method can be used to resolve and release an object automatically. /// You can use the object in <see cref="func" /> and return a value. /// </summary> /// <typeparam name="TService">Type of the service to use</typeparam> /// <typeparam name="TReturn">Return type</typeparam> /// <param name="iocManager">IIocManager object</param> /// <param name="func">A function that can use the resolved object</param> /// <returns></returns> public static TReturn ResolveUsing <TService, TReturn>(this IIocManager iocManager, Func <TService, TReturn> func) { using (IDisposableDependencyObjectWrapper <TService> wrapper = iocManager.ResolveAsDisposable <TService>()) { return(func(wrapper.Object)); } }
/// <summary> /// 订单支付成功 /// </summary> /// <param name="productManagerDisposable"></param> /// <param name="userDownloadConfigManagerDisposable"></param> /// <param name="userManagerDisposable"></param> /// <param name="order"></param> /// <returns></returns> private async Task SuccessPay( IDisposableDependencyObjectWrapper <IProductManager> productManagerDisposable, IDisposableDependencyObjectWrapper <IUserDownloadConfigManager> userDownloadConfigManagerDisposable, IDisposableDependencyObjectWrapper <AbpUserManager <Role, User> > userManagerDisposable, Order order ) { // 获取产品 var product = await productManagerDisposable.Object.GetProductByCode(order.ProductCode); // 获取用户 var user = await userManagerDisposable.Object.Users.Where(o => o.Id == order.CreatorUserId) .AsNoTracking() .FirstOrDefaultAsync(); // 设置用户下载配置 await userDownloadConfigManagerDisposable.Object.SetUserDownloadConfig( user, product.Type, order.ProductCode, order.ProductCreateProjectCount, order.ProductIndate); // 修改订单状态 order.Status = OrderStatusEnum.ChangeHands; await _orderManager.Update(order); }
/// <summary> /// Create a new unit of work scope. /// </summary> public UnitOfWorkScope(bool isTransactional) { //There is already a uow, do nothing if (Current != null) { return; } //this scope started the uow _isStartedByThisScope = true; _unitOfWorkWrapper = IocHelper.ResolveAsDisposable<IUnitOfWork>(); Current = _unitOfWorkWrapper.Object; try { Current.Initialize(isTransactional); Current.Begin(); } catch { Current = null; _unitOfWorkWrapper.Dispose(); throw; } }
public Task <ExternalAuthUserInfo> GetUserInfo(string provider, string accessCode) { using (IDisposableDependencyObjectWrapper <IExternalAuthProviderApi> providerApi = CreateProviderApi(provider)) { return(providerApi.Object.GetUserInfo(accessCode)); } }
public void ResolveAsDisposable_With_Constructor_Args_Should_Work() { Building(builder => { builder.RegisterServices(f => f.RegisterType <SimpleDisposableObject>()); }); using (IDisposableDependencyObjectWrapper <SimpleDisposableObject> wrapper = LocalIocManager.ResolveAsDisposable <SimpleDisposableObject>(new { myData = 42 })) { wrapper.Object.MyData.ShouldBe(42); } }
public Task <bool> IsValidUser(string provider, string providerKey, string providerAccessCode) { Task <bool> result; using (IDisposableDependencyObjectWrapper <IExternalAuthProviderApi> disposableDependencyObjectWrapper = this.CreateProviderApi(provider)) { result = disposableDependencyObjectWrapper.Object.IsValidUser(providerKey, providerAccessCode); } return(result); }
public Task <ExternalAuthUserInfo> GetUserInfo(string provider, string accessCode) { Task <ExternalAuthUserInfo> userInfo; using (IDisposableDependencyObjectWrapper <IExternalAuthProviderApi> disposableDependencyObjectWrapper = this.CreateProviderApi(provider)) { userInfo = disposableDependencyObjectWrapper.Object.GetUserInfo(accessCode); } return(userInfo); }
private Task <Release> GetReleaseFromCache(IDisposableDependencyObjectWrapper <GitHubClient> gitHubClient) { return(_cacheManager.GetCache(CacheNames.ReleaseCache) .GetAsync(CacheNames.ReleaseCache, async() => await gitHubClient.Object .Repository .Release .GetLatest( _configurations.ApplicationConfiguration.GitHubRepositoryOwnerName, _configurations.ApplicationConfiguration.GitHubRepositoryName))); }
private DbContext GetDbContext(ActiveTransactionProviderArgs args) { Type dbContextProviderType = typeof(IDbContextProvider <>).MakeGenericType((Type)args["ContextType"]); using (IDisposableDependencyObjectWrapper dbContextProviderWrapper = _iocResolver.ResolveAsDisposable(dbContextProviderType)) { MethodInfo method = dbContextProviderWrapper.Object.GetType() .GetMethod("GetDbContext"); return((DbContext)method.Invoke(dbContextProviderWrapper.Object, new object[0])); } }
public void IocManager_ShouldResolveDisposableDependency_And_Dispose_After_Scope_Finished() { Building(builder => { builder.RegisterServices(f => f.RegisterType <SimpleDisposableDependency>(Lifetime.LifetimeScope)); }); SimpleDisposableDependency simpleDisposableDependency; using (IDisposableDependencyObjectWrapper <SimpleDisposableDependency> simpleDependencyWrapper = LocalIocManager.ResolveAsDisposable <SimpleDisposableDependency>()) { simpleDisposableDependency = simpleDependencyWrapper.Object; } simpleDisposableDependency.DisposeCount.ShouldBe(1); }
/// <summary> /// Create a new unit of work scope. /// </summary> public UnitOfWorkScope() { _unitOfWorkWrapper = IocHelper.ResolveAsDisposable <IUnitOfWork>(); CurrentUow = _unitOfWorkWrapper.Object; try { CurrentUow.BeginTransaction(); } catch { CurrentUow = null; } }
public IDisposableDependencyObjectWrapper <IExternalAuthProviderApi> CreateProviderApi(string provider) { ExternalLoginProviderInfo externalLoginProviderInfo = this._externalAuthConfiguration.Providers.FirstOrDefault((ExternalLoginProviderInfo p) => p.Name == provider); if (externalLoginProviderInfo == null) { throw new Exception("Unknown external auth provider: " + provider); } IDisposableDependencyObjectWrapper <IExternalAuthProviderApi> disposableDependencyObjectWrapper = IocResolverExtensions.ResolveAsDisposable <IExternalAuthProviderApi>(this._iocResolver, externalLoginProviderInfo.ProviderApiType); disposableDependencyObjectWrapper.Object.Initialize(externalLoginProviderInfo); return(disposableDependencyObjectWrapper); }
/// <summary> /// Create a new unit of work scope. /// </summary> public UnitOfWorkScope() { _unitOfWorkWrapper = IocHelper.ResolveAsDisposable<IUnitOfWork>(); CurrentUow = _unitOfWorkWrapper.Object; try { CurrentUow.BeginTransaction(); } catch { CurrentUow = null; } }
/// <summary> /// Create a new unit of work scope. /// </summary> public UnitOfWorkScope(bool isTransactional) { _unitOfWorkWrapper = IocHelper.ResolveAsDisposable<IUnitOfWork>(); Current = _unitOfWorkWrapper.Object; try { Current.Begin(isTransactional); } catch { Current = null; } }
public IDisposableDependencyObjectWrapper <IExternalAuthProviderApi> CreateProviderApi(string provider) { ExternalLoginProviderInfo providerInfo = _externalAuthConfiguration.Providers.FirstOrDefault(p => p.Name == provider); if (providerInfo == null) { throw new Exception("Unknown external auth provider: " + provider); } IDisposableDependencyObjectWrapper <IExternalAuthProviderApi> providerApi = _iocResolver.ResolveAsDisposable <IExternalAuthProviderApi>(providerInfo.ProviderApiType); providerApi.Object.Initialize(providerInfo); return(providerApi); }
private static void WithDbContext <TDbContext>(IIocResolver iocResolver, Action <TDbContext> contextAction) where TDbContext : DbContext { using (IDisposableDependencyObjectWrapper <IUnitOfWorkManager> uowManager = iocResolver.ResolveAsDisposable <IUnitOfWorkManager>()) { using (IUnitOfWorkCompleteHandle uow = uowManager.Object.Begin(TransactionScopeOption.Suppress)) { TDbContext context = uowManager.Object.Current.GetDbContext <TDbContext>(MultiTenancySides.Host); contextAction(context); uow.Complete(); } } }
public static void CreateOrConsolidate(this IClientConfiguration clientConfiguration, Action <IClientConfiguration> creator) { using (IDisposableDependencyObjectWrapper <IAppConfigManager> appConfigManager = IocManager.Instance.ResolveAsDisposable <IAppConfigManager>()) { using ( IDisposableDependencyObjectWrapper <IApplicationConfiguration> appConfiguration = IocManager.Instance.ResolveAsDisposable <IApplicationConfiguration>()) { creator(clientConfiguration); appConfiguration.Object.ClientConfiguration = clientConfiguration; appConfigManager.Object.SaveOrUpdate("ClientId", clientConfiguration.Id); } } }
private DbContext GetDbContext(ActiveTransactionProviderArgs args) { Type dbContextProviderType = typeof(IDbContextProvider <>).MakeGenericType((Type)args["ContextType"]); using (IDisposableDependencyObjectWrapper dbContextProviderWrapper = _iocResolver.ResolveAsDisposable(dbContextProviderType)) { MethodInfo method = dbContextProviderWrapper.Object.GetType() .GetMethod( nameof(IDbContextProvider <CodeZeroDbContext> .GetDbContext), new[] { typeof(MultiTenancySides) } ); return((DbContext)method.Invoke( dbContextProviderWrapper.Object, new object[] { (MultiTenancySides?)args["MultiTenancySide"] } )); } }
private async Task <DbContext> GetDbContextAsync(ActiveTransactionProviderArgs args) { var dbContextProviderType = typeof(IDbContextProvider <>).MakeGenericType((Type)args["ContextType"]); using (IDisposableDependencyObjectWrapper dbContextProviderWrapper = _iocResolver.ResolveAsDisposable(dbContextProviderType)) { var method = dbContextProviderWrapper.Object.GetType() .GetMethod( nameof(IDbContextProvider <AbpDbContext> .GetDbContextAsync), new[] { typeof(MultiTenancySides) } ); var result = await ReflectionHelper.InvokeAsync(method, dbContextProviderWrapper.Object, new object[] { (MultiTenancySides?)args["MultiTenancySide"] }); return(result as DbContext); } }
private void RegisterGenericRepositories() { base.IocManager.Register <ExtendedRepositoryRegistrar>(); ITypeFinder tFinder = this._typeFinder; Type[] dbContextTypes = tFinder.Find(ExtendedDbContextHelper.DoesDBNeedRegisterGenericRepositories); if (dbContextTypes.IsNullOrEmpty <Type>()) { this.Logger.Warn("No class found derived from ExtendedDbContextBase."); return; } using (IDisposableDependencyObjectWrapper <ExtendedRepositoryRegistrar> repositoryRegistrar = base.IocManager.ResolveAsDisposable <ExtendedRepositoryRegistrar>()) { Type[] array = dbContextTypes; for (int i = 0; i < array.Length; i++) { Type dbContextType = array[i]; repositoryRegistrar.Object.RegisterForDbContext(dbContextType, base.IocManager); } } }
public static void Main(string[] args) { ParseArgs(args); using (AbpBootstrapper bootstrapper = AbpBootstrapper.Create <WebShopMigratorModule>()) { bootstrapper.IocManager.IocContainer .AddFacility <LoggingFacility>( f => f.UseAbpLog4Net().WithConfig("log4net.config") ); bootstrapper.Initialize(); using (IDisposableDependencyObjectWrapper <MultiTenantMigrateExecuter> migrateExecuter = bootstrapper.IocManager.ResolveAsDisposable <MultiTenantMigrateExecuter>()) { bool migrationSucceeded = migrateExecuter.Object.Run(_quietMode); if (_quietMode) { // exit clean (with exit code 0) if migration is a success, otherwise exit with code 1 int exitCode = Convert.ToInt32(!migrationSucceeded); Environment.Exit(exitCode); } else { Console.WriteLine("Press ENTER to exit..."); Console.ReadLine(); } } } }
private void RegisterDapperGenericRepositories() { Type[] dbContextTypes = _typeFinder.Find(type => type.IsPublic && !type.IsAbstract && type.IsClass && typeof(AbpDbContext).IsAssignableFrom(type) ); using (IDisposableDependencyObjectWrapper <IDapperGenericRepositoryRegistrar> repositoryRegistrar = IocManager.ResolveAsDisposable <IDapperGenericRepositoryRegistrar>()) { foreach (Type dbContextType in dbContextTypes) { Logger.Debug("Registering DbContext: " + dbContextType.AssemblyQualifiedName); repositoryRegistrar.Object.RegisterForDbContext(dbContextType, IocManager); } } }