public void DropTableTest() { // Verifies it is possible to perform operations following drop table ISampleRepository sampleRepository = RepositoryContext.SampleRepository; Assert.NotNull(sampleRepository); var comparisonItem = _singleOperationsTestData; // Create (insert) operation (before drop table) sampleRepository.InsertItemAsync(_singleOperationsTestData).GetAwaiter().GetResult(); // Read (get) operation var item = sampleRepository.GetItemAsync(_singleOperationsTestData.Id).Result; ValidateSampleModelOperation(item, comparisonItem, nameof(sampleRepository.InsertItemAsync)); // Perform Drop Table operation sampleRepository.DropTableAsync().GetAwaiter().GetResult(); // Create (insert) operation (after drop table) sampleRepository.InsertItemAsync(_singleOperationsTestData).GetAwaiter().GetResult(); // Read (get) operation item = sampleRepository.GetItemAsync(_singleOperationsTestData.Id).Result; ValidateSampleModelOperation(item, comparisonItem, nameof(sampleRepository.InsertItemAsync)); }
public static async Task InsertAsync(ILogger logger, ISampleRepository repository, int count) { logger.LogInformation("Before measure"); var data = SampleEntity.CreateList(count); using var tx = new TransactionScope(TransactionScopeOption.Required, TransactionScopeAsyncFlowOption.Enabled); var sw = new Stopwatch(); sw.Start(); await repository.AddAsync(data); sw.Stop(); tx.Complete(); logger.LogMetric("InsertPerformance", sw.ElapsedMilliseconds, new Dictionary <string, object> { { "Repository", repository.GetType().Name }, { "Count", count } }); logger.LogInformation("After measure"); }
public ProductService(IUnitOfWork unitOfWork, ISampleRepository repository, IContainer container, IEventBus eventBus, IMessagePublisher messagePublisher) : base(unitOfWork, repository, container) { _eventBus = eventBus; _messagePublisher = messagePublisher; }
public HomeController(ISampleRepository repository) { _repository = repository; //default intro message IntroMessage = "Hello World"; }
public SampleOptionsService(ISampleRepository repository, IUnitOfWork unitOfWork, IMapper mapper, ISampleService sampleService) { _repository = repository ?? throw new ArgumentNullException(nameof(repository)); _unitOfWork = unitOfWork ?? throw new ArgumentNullException(nameof(unitOfWork)); _mapper = mapper ?? throw new ArgumentNullException(nameof(mapper)); _sampleService = sampleService ?? throw new ArgumentNullException(nameof(sampleService)); }
public void SingleUpdatePerformanceTest(int itemsToUpdate) { ISampleRepository sampleRepository = RepositoryContext.SampleRepository; var testData = TestData.GenerateBulkOperationsTestData(itemsToUpdate); // Insert initial data sampleRepository.InsertAsync(testData).GetAwaiter().GetResult(); // Get persisted data var persistedItems = sampleRepository.GetAsync().GetAwaiter().GetResult(); // Update local copies of persisted data UpdateItems(ref persistedItems); // Perform and measure update operations var executionTime = ExecutionTimeInMilliseconds(() => { foreach (var item in persistedItems) { sampleRepository.UpdateItemAsync(item).GetAwaiter().GetResult(); } }); Assert.Pass($"{itemsToUpdate} records updated: {executionTime} ms"); }
public SampleMoreController(ISampleRepository rep, ISampleApplicationService app, ILoggerFactory logger, EnviromentInfo env) { this._rep = rep; this._app = app; this._logger = logger.CreateLogger <SampleMoreController>(); this._env = env; }
public SampleService(ISampleRepository sampleRepository, ISampleArchRepository sampleArchRepository) : base(sampleRepository) { // _unitOfWork = unitOfWork; _sampleRepository = sampleRepository; _sampleArchRepository = sampleArchRepository; }
public HomeController(ISampleRepository repository) { _repository = repository; //default intro message IntroMessage = "Hello World"; }
public SampleFrontendSvcController(ISampleRepository repository, IPublishEndpoint publishEndpoint, /*IMapper mapper,*/ ILogger logger, IConfiguration config) { _repository = repository ?? throw new ArgumentNullException(nameof(repository)); _publishEndpoint = publishEndpoint ?? throw new ArgumentNullException(nameof(publishEndpoint)); _logger = logger; _config = config; }
public MyCommandHandler(IEventBus eventBus, ISampleRepository repositroy, IUnitOfWork uow, IMessageContext commandContext) { _commandContext = commandContext; _repository = repositroy; _eventBus = eventBus; _unitOfWork = uow; }
public SampleServiceBase(ISampleRepository rep, IValidatorSpecification <Sample> validation, IWarningSpecification <Sample> warning, ICache cache, CurrentUser user) : base(cache) { this._rep = rep; this._user = user; this._validation = validation; this._warning = warning; }
public SampleSingleDbContextUnitOfWork(ISampleDatabaseDbContext dbContext , ISampleRepository sampleRepository, ISampleRepository2 sampleRepository2) : base(dbContext, sampleRepository, sampleRepository2) { DbContext = dbContext; SampleRepository = sampleRepository; SampleRepository2 = sampleRepository2; }
public SamplesController(ISampleRepository sampleRepository , IMapper mapper) { _sampleRepository = sampleRepository ?? throw new ArgumentNullException(nameof(sampleRepository)); _mapper = mapper ?? throw new ArgumentNullException(nameof(mapper)); }
public DeleteHandler(IEventPublisher eventPublisher, ISampleRepository sampleRepository, IUnitOfWork unitOfWork, ILogger <DeleteRequest> logger) : base(eventPublisher, logger) { _sampleRepository = sampleRepository; _unitOfWork = unitOfWork; }
public AccountService(IMapper mapper, ISampleRepository sampleRepository, UserManager <ApiUser> userManager, SignInManager <ApiUser> signInManager, IEmailSender emailSender) { _mapper = mapper; _sampleRepository = sampleRepository; _userManager = userManager; _signInManager = signInManager; _emailSender = emailSender; }
public OrdersController(ISampleRepository repository, ILogger <OrdersController> logger, IMapper mapper) { this.repository = repository; this.logger = logger; this.mapper = mapper; }
public SampleController(ISampleRepository sampleRepository, IUserProfileRepository userProfileRepository, IReportRepository reportRepository) { _sampleRepository = sampleRepository; _userProfileRepository = userProfileRepository; _reportRepository = reportRepository; }
public ProductService(IProductRepository ProductsRepository, IProductCategoryRepository productCategoryRepository, IUnitOfWork unitOfWork, IProductSampleRepository productSampleRepository, ISampleRepository sampleRepository) { this._productsRepository = ProductsRepository; this._productCategoryRepository = productCategoryRepository; this._productSampleRepository = productSampleRepository; this._sampleRepository = sampleRepository; this.unitOfWork = unitOfWork; }
protected override void Dispose(bool disposing) { if (disposing) { repo = null; } base.Dispose(disposing); }
public InsertHandler(IEventPublisher eventPublisher, ISampleRepository sampleRepository, IUnitOfWork unitOfWork, ISampleService sampleService, ILogger <InsertRequest> logger) : base(eventPublisher, logger) { _sampleRepository = sampleRepository; _unitOfWork = unitOfWork; _sampleService = sampleService; }
public void SQLSampleRepository_Get_Sample_By_Id() { ISampleRepository sut = GetInMemorySampleRepository(); List <SampleModel> samples = sampleInMemoryDb(); SampleModel savedSample1 = sut.Add(samples[0]); sut.GetSample(savedSample1.Id); Assert.Equal(123, savedSample1.Donor_Count); }
public SampleMoreController(ISampleRepository rep, ISampleApplicationService app, ILoggerFactory logger, EnviromentInfo env, CurrentUser user, ICache cache) { this._rep = rep; this._app = app; this._logger = logger.CreateLogger <SampleMoreController>(); this._env = env; this._user = user; this._cache = cache; this._cacheHelper = new CacheHelper(this._cache); }
public UpdateHandler(IEventPublisher eventPublisher, ISampleRepository sampleRepository, IUnitOfWork unitOfWork, ISampleAdapter sampleAdapter, ILogger <UpdateRequest> logger) : base(eventPublisher, logger) { _sampleRepository = sampleRepository; _unitOfWork = unitOfWork; _sampleAdapter = sampleAdapter; }
public void BulkInsertOperationsPerformanceTest(int insertionsToTest) { ISampleRepository sampleRepository = RepositoryContext.SampleRepository; var testData = TestData.GenerateBulkOperationsTestData(insertionsToTest); // Perform and measure insert operations var executionTime = ExecutionTimeInMilliseconds(() => sampleRepository.InsertAsync(testData).GetAwaiter().GetResult()); Assert.Pass($"{insertionsToTest} records inserted: {executionTime} ms"); }
public SampleModel(ISampleRepository repository) { if (repository == null) { throw new ArgumentNullException("repository"); } this.repository = repository; Trace.WriteLine("Instantiating SampleModel.."); Trace.WriteLine("HashCode: " + GetHashCode()); }
public void SQLSampleRepository_Should_Delete_Sample() { ISampleRepository sut = GetInMemorySampleRepository(); List <SampleModel> samples = sampleInMemoryDb(); sut.Add(samples[0]); Assert.Single(sut.GetAllSamples()); sut.Delete(samples[0].Id); Assert.Empty(sut.GetAllSamples()); }
public void BulkReadPerformanceTest(int itemsToRead) { ISampleRepository sampleRepository = RepositoryContext.SampleRepository; var testData = TestData.GenerateBulkOperationsTestData(itemsToRead); // Insert initial data sampleRepository.InsertAsync(testData).GetAwaiter().GetResult(); // Perform and measure read operations var executionTime = ExecutionTimeInMilliseconds(() => sampleRepository.GetAsync().GetAwaiter().GetResult()); Assert.Pass($"{itemsToRead} records read: {executionTime} ms"); }
public SampleApi(ISampleRepository sampleRepository, ISampleViewModelService sampleViewModelService, IMapper mapper, ITemplateCosmosRepository templateCosmosRepository, IBlobStorageService blobStorageService ) { _sampleRepository = sampleRepository; _sampleViewModelService = sampleViewModelService; _mapper = mapper; _templateCosmosRepository = templateCosmosRepository; _blobStorageService = blobStorageService; }
public void SQLSampleRepository_Should_Update_Sample() { ISampleRepository sut = GetInMemorySampleRepository(); List <SampleModel> samples = sampleInMemoryDb(); sut.Add(samples[0]); Assert.Equal("28/09/2020", samples[0].Last_Updated); samples[0].Last_Updated = "14/10/2020"; sut.Update(samples[0]); Assert.Equal("14/10/2020", samples[0].Last_Updated); }
public void SQLSpampleRepository_Should_Get_All_Samples() { ISampleRepository sut = GetInMemorySampleRepository(); List <SampleModel> samples = sampleInMemoryDb(); SampleModel savedSample1 = sut.Add(samples[0]); SampleModel savedSample2 = sut.Add(samples[1]); sut.GetAllSamples(); Assert.Equal(2, samples.Count); Assert.Equal(123, savedSample1.Donor_Count); Assert.Equal(5592, savedSample2.Donor_Count); }
public SampleController(ISampleRepository sampleRepository) { this.sampleRepository = sampleRepository; }
// ReSharper restore UnusedParameter.Local public SampleService(ISampleRepository repo) { Repository = repo; }
public SampleService(ISampleRepository sampleRepository, IUnitOfWork unitOfWork) { this.sampleRepository = sampleRepository; this.unitOfWork = unitOfWork; }
public SampleService(ISampleRepository sampleRepository) { this.SampleRepository = sampleRepository; }
public SampleService(ISampleRepository repository) { _repository = repository; }
public SampleController(ISampleRepository repository) { Repository = repository; }
public SampleService(string b, ISampleRepository repo, string c) { }
public FooService(ISampleRepository sampleRepository) { this.sampleRepository = sampleRepository; }
// ReSharper disable UnusedParameter.Local public SampleService(ISampleRepository repo1, string b, ISampleRepository repo2) { B = b; }