private async Task <List <Opportunity> > GetRandomRecentOpportunities(
int takeFromTopCount,
int numberOfOpportunitiesToInclude)
{
var opportunities = await MemoryCacheImpl.GetOpportunitiesAcceptingApplications(_memory, _context);
opportunities.Sort();
opportunities.Reverse();
if (opportunities.Count > takeFromTopCount)
{
opportunities = opportunities.Take(takeFromTopCount).ToList();
}
var filteredOpportunities = opportunities;
if (filteredOpportunities.Count > numberOfOpportunitiesToInclude)
{
filteredOpportunities = new List <Opportunity>();
var filteredOpportunityIds = new List <int>();
Random random = new Random();
while (filteredOpportunities.Count < numberOfOpportunitiesToInclude)
{
var opportunity = opportunities[random.Next(opportunities.Count)];
if (!filteredOpportunityIds.Contains(opportunity.Id))
{
filteredOpportunities.Add(opportunity);
filteredOpportunityIds.Add(opportunity.Id);
}
}
}
return(filteredOpportunities);
}
public async Task <IActionResult> SendAsync(SendViewModel model)
{
if (model.OpportunityIds == null || model.OpportunityIds.Count == 0)
{
TempData["Messages"] = "No opportunities selected, no newsletters delivered.";
return(RedirectToAction(nameof(Index)));
}
var opportunities = await MemoryCacheImpl.GetOpportunitiesAcceptingApplications(_memory, _context);
var html = GenerateSendGridHtmlFromOpportunities(
opportunities
.Where(x => model.OpportunityIds.Contains(x.Id))
.ToList());
var response = await _sendgridClient.SendNewsletterAsync(html);
var res = await response.Body.ReadAsStringAsync();
if (response.StatusCode.Equals(HttpStatusCode.Accepted) ||
response.StatusCode.Equals(HttpStatusCode.OK))
{
TempData["Messages"] = "Newsletter successfully sent";
}
return(RedirectToAction(nameof(Index)));
}
public void MemoryTest(int iterations)
{
// Given
const string cacheName = nameof(MemoryCacheImplMemoryTest);
var memoryCache = new MemoryCacheImpl(cacheName);
const string key = "GetMemoryTest_Key";
double startSize = GC.GetTotalMemory(true);
// When
var cache = memoryCache;
for (var i = 0; i < iterations; ++i)
{
var value = Guid.NewGuid().ToString("N");
cache.Set(key, value);
cache.Get(key);
}
cache.Dispose();
double stopSize = GC.GetTotalMemory(true);
var memoryLeak = (stopSize - startSize);
// Then
Console.WriteLine(@"Iteration count: {0}", iterations);
Console.WriteLine(@"Memory Leak : {0:N2} %", memoryLeak / startSize);
Console.WriteLine(@"Memory Leak : {0:N2} Kb", memoryLeak / 1024);
}
public void SetUp()
{
var connectionString = ConfigurationManager.AppSettings["RedisConnectionString"];
_cacheLayer1 = new MemoryCacheImpl("TwoLayerCacheRealMemoryTest");
_cacheLayer2 = new RedisCacheImpl("TwoLayerCacheRealMemoryTest", connectionString);
_messageBus = new RedisMessageBus(connectionString);
_testCache = new TwoLayerCacheImpl(_cacheLayer1, _cacheLayer2, _messageBus);
}
public PerfomanceTwoLayerRealCacheTest()
{
var connectionString = ConfigurationManager.AppSettings["RedisConnectionString"];
MemoryCacheImpl cacheLayer1 = new MemoryCacheImpl("PerfomanceTwoLayerRealCacheTest");
RedisCacheImpl cacheLayer2 = new RedisCacheImpl("PerfomanceTwoLayerRealCacheTest", connectionString);
RedisMessageBus messageBus = new RedisMessageBus(connectionString);
_testCache = new TwoLayerCacheImpl(cacheLayer1, cacheLayer2, messageBus);
}
public void TearDown()
{
_testCache.Dispose();
_messageBus.Dispose();
_cacheLayer1.Dispose();
_cacheLayer2.Dispose();
_testCache = null;
_messageBus = null;
_cacheLayer1 = null;
_cacheLayer2 = null;
}
public async Task <IActionResult> IndexAsync(int id)
{
List <Opportunity> opportunities = await MemoryCacheImpl.GetOpportunitiesAcceptingApplications(_memoryCache, _context);
OpportunityViewModel opportunityView = opportunities
.Where(x => x.Id == id)
.Select(OpportunityViewModel.FromOpportunity)
.SingleOrDefault();
if (opportunityView == null)
{
return(View(new OpportunityViewModel()));
}
return(View(opportunityView));
}
public void MemoryTest(int iterations)
{
// Given
var cacheName = GetType().Name;
var settings = new RedisConnectionSettings
{
Host = "localhost",
Password = "******"
};
var log = new Mock <ILog>().Object;
var performanceLog = new Mock <IPerformanceLog>().Object;
var memoryCache = new MemoryCacheImpl(cacheName);
var redisCache = new RedisCacheImpl(cacheName, new RedisConnectionFactory(settings), log, performanceLog);
var redisMessageBusManager = new RedisMessageBusManager(cacheName, new RedisConnectionFactory(settings), log, performanceLog);
var redisMessageBusPublisher = new RedisMessageBusPublisher(cacheName, new RedisConnectionFactory(settings), log, performanceLog);
var redisMessageBus = new MessageBusImpl(redisMessageBusManager, redisMessageBusPublisher);
var twoLayerCache = new TwoLayerCacheImpl(memoryCache, redisCache, redisMessageBus);
const string key = "GetMemoryTest_Key";
double startSize = GC.GetTotalMemory(true);
// When
var cache = twoLayerCache;
for (var i = 0; i < iterations; ++i)
{
var value = Guid.NewGuid().ToString("N");
cache.Set(key, value);
cache.Get(key);
}
cache.Dispose();
double stopSize = GC.GetTotalMemory(true);
var memoryLeak = (stopSize - startSize);
// Then
Console.WriteLine(@"Iteration count: {0}", iterations);
Console.WriteLine(@"Memory Leak : {0:N2} %", memoryLeak / startSize);
Console.WriteLine(@"Memory Leak : {0:N2} Kb", memoryLeak / 1024);
}
public async Task <IActionResult> Search([FromBody] OpportunitySearch opportunitySearch)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
List <Opportunity> opportunities = await MemoryCacheImpl.GetOpportunitiesAcceptingApplications(_memoryCache, _context);
List <OpportunityViewModel> opportunityViews = opportunities
.Where(GetEligibleOpportunityPredicate(opportunitySearch))
.Select(OpportunityViewModel.FromOpportunity)
.OrderByDescending(x => x.Id)
.ToList();
return(Ok(opportunityViews));
}
public void SetUp()
{
var cacheName = GetType().Name;
var settings = new RedisConnectionSettings
{
Host = "localhost",
Password = "******"
};
var log = new Mock <ILog>().Object;
var performanceLog = new Mock <IPerformanceLog>().Object;
var memoryCache = new MemoryCacheImpl(cacheName);
var redisCache = new RedisCacheImpl(cacheName, new RedisConnectionFactory(settings), log, performanceLog);
var redisMessageBusManager = new RedisMessageBusManager(cacheName, new RedisConnectionFactory(settings), log, performanceLog);
var redisMessageBusPublisher = new RedisMessageBusPublisher(cacheName, new RedisConnectionFactory(settings), log, performanceLog);
var redisMessageBus = new MessageBusImpl(redisMessageBusManager, redisMessageBusPublisher);
var twoLayerCache = new TwoLayerCacheImpl(memoryCache, redisCache, redisMessageBus);
_cache = twoLayerCache;
}
public void SetUp()
{
_cache = new MemoryCacheImpl(typeof(MemoryCacheImplTest).Name);
}
public void SetUp()
{
_cache = new MemoryCacheImpl("TestMemory");
}
public void SetUp()
{
_cache = new MemoryCacheImpl(nameof(MemoryCacheImplPerformanceTest));
}
public void TearDown()
{
_testCache.Dispose();
_testCache = null;
}
public void SetUp()
{
_testCache = new MemoryCacheImpl("MemoryLayerCacheTest");
}
public PerfomanceMemoryLayerCacheTest()
{
_testCache = new MemoryCacheImpl("PerfomanceRedisLayerCacheTest");
}
