public async Task <ServiceResult <CourseResponse> > UpdateCourse(CourseRequest request)
{
var courseEntity = Mapper.Map <CourseRequest, Course>(request);
var modelState = new Dictionary <string, string[]>();
_unitOfWork.CourseRepository.Update(courseEntity);
// Handle Conflicts here
int result;
if (request.ConflictStrategy == ResolveStrategy.ShowUnresolvedConflicts)
{
var resolveConflicts = ConcurrencyHelper.ResolveConflicts(courseEntity, modelState);
result = await _unitOfWork.SaveAsync(resolveConflicts, userResolveConflict : true);
}
else
{
RefreshConflict refreshMode = (RefreshConflict)request.ConflictStrategy;
if (!EnumExtensions.IsFlagDefined(refreshMode))
{
refreshMode = RefreshConflict.StoreWins;
}
result = _unitOfWork.SaveSingleEntry(refreshMode);
}
return(await GetServiceResult(courseEntity, modelState, result));
}
public void ReleaseKeyLock_HappyPath_CompletesSucessfully(int locksCount, uint keyBucket)
{
var sut = new ConcurrencyHelper(locksCount);
var releaseKeyLock = sut
.Invoking(s => s.ReleaseKeyLock(keyBucket))
.Should().NotThrow();
}
public void TakeKeyLock_HappyPath_ReturnsCorrectBucket(int locksCount, int key, uint expectedBucket)
{
var sut = new ConcurrencyHelper(locksCount);
var bucket = sut.TakeKeyLock(key);
bucket.Should().Be(expectedBucket);
}
public void ReleaseKeyLock_BucketIsOutOfLocksRange_ThrowsException(int locksCount, uint keyBucket)
{
var sut = new ConcurrencyHelper(locksCount);
var releaseKeyLock = sut
.Invoking(s => s.ReleaseKeyLock(keyBucket))
.Should()
.Throw <ArgumentException>().WithMessage("Key bucket is out of locks range (Parameter 'keyBucket')");
}
public async Task Remove(string coffeeName, int weight)
{
var desiredPack = await getDesiredPack(coffeeName, weight);
await ConcurrencyHelper.WithConcurrency <CoffeeOrder>(
userOrder =>
{
userOrder.RemoveCoffeePack(desiredPack);
return(true);
},
async() =>
{
return((await _coffeeOrderRepository.GetUserOrders(User.Identity.Name))
?? new CoffeeOrder(User.Identity.Name));
},
_coffeeOrderRepository.Update);
}
public static void Main(string[] args)
{
var benchmarkDate = DateTime.Now;
#if DEBUG
StackExchangeRedisBenchmarks.DoEvalSetOnLargeString();
var debugModeConcurrencyRunner = new ConcurrencyHelper();
debugModeConcurrencyRunner.RegisterLevel(
() =>
{
StackExchangeRedisBenchmarks.DoEvalSetOnLargeString();
},
1_000,
friendlyName: "redis eval load test",
numberOfRegisters: 20);
debugModeConcurrencyRunner.Start().Wait();
var averageRuntime = debugModeConcurrencyRunner.GetAverageActionRuntime();
#else
var redisSummary = BenchmarkRunner.Run <StackExchangeRedisBenchmarks>();
Save("Performance.StackExchange.Redis", DateTime.Now);
#endif
}
private static IFormatter CreateFormatter()
{
var formatterName = ConfigurationManager.AppSettings["Rpc.DefaultFormatter"];
formatterName = (formatterName ?? String.Empty);
var makeFormatterThreadSafe = ConfigurationManager.AppSettings["Rpc.MakeFormatterThreadSafe"];
makeFormatterThreadSafe = (makeFormatterThreadSafe ?? String.Empty);
if (!String.IsNullOrWhiteSpace(formatterName))
{
var formatterType = ReflectionUtil.FindType(formatterName);
if (formatterType != null)
{
if (typeof(IFormatter).IsAssignableFrom(formatterType))
{
if (makeFormatterThreadSafe == "true" || makeFormatterThreadSafe == "yes" || makeFormatterThreadSafe == "1")
{
var concurrentFormatter = ConcurrencyHelper.CreateFormatter(() => (IFormatter)Activator.CreateInstance(formatterType));
return(concurrentFormatter);
}
var formatterInst = (IFormatter)Activator.CreateInstance(formatterType);
if (formatterInst != null)
{
return(formatterInst);
}
}
}
}
var formatter = ConcurrencyHelper.CreateFormatter(() => new AdvancedBinaryFormatter());
return(formatter);
}
