public RedisEventBus(IRedisRepository _redisRepository, ILogger <RedisEventBus> _logger, IServiceProvider _serviceProvider, ISubscribeMessageStorage _messageStorage) { redisSubscribe = _redisRepository.Subscribe; logger = _logger; serviceProvider = _serviceProvider; messageStorage = _messageStorage; }
public GetOrderWithIdRequestHandler( IOrderRepository <Order> repository, IRedisRepository redisRepository) { _repository = repository ?? throw new ArgumentNullException(nameof(repository)); _redisRepository = redisRepository ?? throw new ArgumentNullException(nameof(redisRepository)); }
/// <summary> /// 建構式 /// </summary> /// <param name="logger">logger</param> /// <param name="mapper">mapper</param> /// <param name="mgtRepository">mgtRepository</param> /// <param name="redisRepository">redisRepository</param> public MgtService(ILogger <MgtService> logger, IMapper mapper, IMgtRepository mgtRepository, IRedisRepository redisRepository) { this.logger = logger; this.mapper = mapper; this.mgtRepository = mgtRepository; this.redisRepository = redisRepository; }
public RatesControllerTest() { _logger = new RatesControllerLogerFake(); _distributedCacheFake = new DistributedCacheFake(); _redisRepository = new RedisRepository(_distributedCacheFake, null); _ratesController = new RatesController(_redisRepository, _logger); }
public RedisSubscribeEvent(IRedisRepository _redis, ILogger <RedisSubscribeEvent> _logger, ISubscribeHandler _subscribeHandler) { redis = _redis; logger = _logger; subscribeHandler = _subscribeHandler; }
public PartyHub(IDistributedCache cache, IRedisRepository redisRepository, ILadderService ladderService, TelemetryClient telemetry) { _cache = cache; _redisRepository = redisRepository; _ladderService = ladderService; _telemetry = telemetry; }
public static void Init(TestContext context) { IConfiguration configurationProvider = CreateConfigurationProvider(); IRedisCacheFactory redisCacheFactory = new RedisCacheFactory(configurationProvider); _redisRepository = new RedisRepository(redisCacheFactory); }
public UserAuth(IHttpContextAccessor httpContextAccessor, IRedisRepository redisRepository) { Console.WriteLine($"UserAuth:{redisRepository}"); this._accessor = httpContextAccessor; this.redisRepository = redisRepository; Console.WriteLine($"UserAuth.1:{redisRepository}"); }
public LocalJobTest() { _mongoRepository = new MongoRepositoryFake(); _redisRepository = new RedisRepositoryFake(); _exchangeProviderFactory = new ExchangeProviderFactoryFake(); _job = new LocalJob(_exchangeProviderFactory, _mongoRepository, _redisRepository, null); }
public RedisController(DependencyInjectionManager manager) { _manager = manager; using (var scope = _manager.ServiceProvider.CreateScope()) { _redisRepo = scope.ServiceProvider.GetService <IRedisRepository>(); } }
public RedisCachingRepository(string connectionString, TimeSpan throttlingInterval, CancellationToken cancellationToken) { _inner = new RedisRepository(connectionString); _cache = new ConcurrentDictionary <string, uint>(); _queue = new ConcurrentQueue <QueueItem>(); _throttlingInterval = throttlingInterval; _cancellationToken = cancellationToken; }
public RedisTest() { //注入redis仓储服务 services.AddRedisRepository(options => { options.Connection = new string[] { "" }; options.RedisPrefix = new RedisPrefixKey(); }); redis = services.BuildServiceProvider().GetService <IRedisRepository>(); }
public OERJob(IExchangeProviderFactory exchangeProviderFactory, IMongoRepository mongoRepository, IRedisRepository redisRepository, ILogger <OERJob> logger) { _exchangeProviderFactory = exchangeProviderFactory; _mongoRepository = mongoRepository; _redisRepository = redisRepository; _logger = logger; }
public BaseService( IUnitOfWork uow, ISQLRepository <T, Tid> sqlServerRepository, IRedisRepository <T, Tid> redisRepository, AbstractValidator <T> validator) { _uow = uow; _sqlServerRepository = sqlServerRepository; _redisRepository = redisRepository; _validator = validator; }
public static void Init(TestContext context) { IConfiguration configurationProvider = CreateConfigurationProvider(); ICosmosFactory cosmosfactory = new CosmosFactory(configurationProvider); _cosmosRepository = A.Fake <SqlCosmosRepository>(arg => arg.WithArgumentsForConstructor(new object[] { cosmosfactory })); IRedisCacheFactory redisCacheFactory = new RedisCacheFactory(configurationProvider); _redisRepository = new RedisRepository(redisCacheFactory); _writeThroughStrategy = A.Fake <WriteThroughStrategy>(x => x.WithArgumentsForConstructor(new Object[] { _redisRepository, _cosmosRepository })); }
public UserService( IConfiguration config, IRepository repository, IMongoRepository mongoUserRepository = null, IRedisRepository redisRepository = null ) { _useDb = (ConnectDb)int.Parse(config.GetSection(DbConnectionConst.UseDbKey).Value); _userRepository = repository; _mongoUserRepository = mongoUserRepository; _redisUserRepository = redisRepository; }
public LadderService( IHostingEnvironment env, ILogger <LadderService> log, IExternalService externalService, IRedisRepository redisRepository ) { _log = log; _env = env; _externalService = externalService; _redisRepository = redisRepository; }
public BasketService(IMongoRepository <Basket> mongoRepository, ISQLRepository <Product> productRepository, ISQLRepository <Stock> stockRepository, IRedisRepository redisRepository, IBasketRepository basketRepository) { _basketRepository = basketRepository; _mongoRepository = mongoRepository; _productRepository = productRepository; _stockRepository = stockRepository; _redisRepository = redisRepository; }
public static void Init(TestContext context) { IConfiguration configurationProvider = CreateConfigurationProvider(); ICosmosFactory cosmosfactory = new CosmosFactory(configurationProvider); // creating a fake instance of cosmos so as to be able to asset the invocations using fakeiteasy // note: this is fake instance and does not hold a reference to the actual cosmos DB _cosmosRepository = A.Fake <ICosmosRepository>(); IRedisCacheFactory redisCacheFactory = new RedisCacheFactory(configurationProvider); _redisRepository = new RedisRepository(redisCacheFactory); _readThroughStrategy = A.Fake <ReadThroughStrategy>(x => x.WithArgumentsForConstructor(new Object[] { _redisRepository, _cosmosRepository })); }
public MongoDBRepository() { #region Initialize var builder = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true); var configuration = builder.Build(); if (configuration.GetChildren().Count() > 0) { _mongoDBConnectionString = configuration["MongoRedi:MongoDBConnectionString"]; _mongoDBDatabase = configuration["MongoRedi:MongoDBDatabase"]; _redisConnectionString = configuration["MongoRedi:RedisConnectionString"]; _redisDatabase = configuration["MongoRedi:RedisDatabase"]; _enableCache = Convert.ToBoolean(configuration["MongoRedi:Cache"]); } else { _mongoDBConnectionString = ConfigurationManager.AppSettings["MongoRedi_MongoDBConnectionString"]; _mongoDBDatabase = ConfigurationManager.AppSettings["MongoRedi_MongoDBDatabase"]; _redisConnectionString = ConfigurationManager.AppSettings["MongoRedi_RedisConnectionString"]; _redisDatabase = ConfigurationManager.AppSettings["MongoRedi_RedisDatabase"]; _enableCache = Convert.ToBoolean(ConfigurationManager.AppSettings["MongoRedi_Cache"]); } #endregion _mongoClient = new MongoClient(_mongoDBConnectionString); _mongoDatabase = _mongoClient.GetDatabase(_mongoDBDatabase); var collectionName = (typeof(TCollection).GetCustomAttributes(typeof(CollectionNameAttribute), true)[0] as CollectionNameAttribute).CollectionName; _collection = _mongoDatabase.GetCollection <TCollection>(collectionName); _cacheCollection = typeof(TCollection).IsDefined(typeof(CacheCollectionAttribute), false) && _enableCache; _cacheDocument = typeof(TCollection).IsDefined(typeof(CacheDocumentAttribute), false) && _enableCache; if (_cacheCollection || _cacheDocument) { _redisRepository = new RedisRepository(_redisConnectionString, _redisDatabase); } }
public IActionResult Register([FromBody] RegisterModel model, [FromServices] IRedisRepository redisRepository, [FromServices] ITentantRedisResolver tentantResolver) { var result = tentantResolver.Find(); using (var context = new TenantDbContext(result.Tenant)) { var repository = new EfRepository <User>(context); repository.Insert(new User { Name = "unkown", Password = "******" }); } //返回ID return(Ok()); }
public void AddRedisBranch_AddBranchesToServiceCollectionAndBuildProvider_GetRedisBranch() { //Arrange IServiceCollection services = new ServiceCollection(); services.AddSingleton <IConnectionMultiplexer>(sp => { return(FakesFactory.CreateConnectionMultiplexerFake()); }); //Act services.AddRedisBranch(Assembly.GetExecutingAssembly()); ServiceProvider provider = services.BuildServiceProvider(); IRedisRepository <StockEntity> notNullStockEntity = provider.GetRequiredService <IRedisRepository <StockEntity> >(); //Assert Assert.NotNull(notNullStockEntity); }
public EfTokenRepository(DatabaseContext context, IRedisRepository <TokenUser> redisRepository, IConfiguration configuration) { this._context = context; this._redisRepository = redisRepository; _configuration = configuration; }
public DeleteByScoreController(IRedisRepository redisRepository, IRedisRepositorySortedSet redisRepositorySortedSet) { _redisRepository = redisRepository; _redisRepositorySortedSet = redisRepositorySortedSet; }
public CheckLoginAttribute(IRedisRepository redisRepository) { this.redisRepository = redisRepository; }
public HealthController(IRedisRepository redisRepository) { _redisRepository = redisRepository; }
public MongoDockerCommandsRepository(IRedisRepository redisRepository) { _redisRepository = redisRepository; _context = new DockerCommandsContext(); }
public CommonController(IRedisRepository redis) { _redis = redis; }
public RefreshTokenProvider() { IDependencyResolver container = GlobalConfiguration.Configuration.DependencyResolver; _redisRepo = (IRedisRepository)container.GetService(typeof(IRedisRepository)); }
public RefreshTokenProvider(IRedisRepository redisRepository) { _redisRepo = redisRepository; }
public AccountController(IUserRepository userRepository, IRedisRepository redis) { _redis = redis; _userRepository = userRepository; }
public BaseRepository() { Db = new FsDataContext(); RedisRepository = new RedisRepository(); }
public FirstBusiness(IRedisRepository redisRepository) { _redisRepository = redisRepository; }
public PartyHub(IDistributedCache cache, IRedisRepository redisRepository, ILadderService ladderService) { _cache = cache; _redisRepository = redisRepository; _ladderService = ladderService; }
public RedisService(IRedisRepository redisRepository) { _redisRepository = redisRepository; }