public void AddAndGet()
{
var c = new SynchronizedCache();
var lst = new List<Task>();
for (var i = 0; i < 10; i++)
{
var i1 = i;
var t = new Task(() => c.Add(i1, i1.ToString()));
t.Start();
lst.Add(t);
}
Task.WaitAll(lst.ToArray());
Assert.AreEqual(c.Count, 10);
lst.Clear();
for (var i = 0; i < 10; i++)
{
var i1 = i;
var t = new Task(() =>
{
var s = c.Read(i1);
Assert.AreEqual(s, i1.ToString());
c.Update(i1, "42");
});
t.Start();
lst.Add(t);
}
Task.WaitAll(lst.ToArray());
for (var i = 0; i < 10; i++)
{
var s = c.Read(i);
Assert.AreEqual(s, "42");
}
}
public void AddAndGet()
{
var c = new SynchronizedCache();
var lst = new List <Task>();
for (var i = 0; i < 10; i++)
{
var i1 = i;
var t = new Task(() => c.Add(i1, i1.ToString()));
t.Start();
lst.Add(t);
}
Task.WaitAll(lst.ToArray());
Assert.AreEqual(c.Count, 10);
lst.Clear();
for (var i = 0; i < 10; i++)
{
var i1 = i;
var t = new Task(() =>
{
var s = c.Read(i1);
Assert.AreEqual(s, i1.ToString());
c.Update(i1, "42");
});
t.Start();
lst.Add(t);
}
Task.WaitAll(lst.ToArray());
for (var i = 0; i < 10; i++)
{
var s = c.Read(i);
Assert.AreEqual(s, "42");
}
}
public void TryAdd_WhenItemExistsInCache_DuplicateItemNotAdded_Concurrent()
{
// Arrange
var sut = new SynchronizedCache <string, string>();
Parallel.For(0, 100, _ => sut.TryAdd("key", "value"));
// Assert
Assert.AreEqual(1, sut.Count);
}
public void Indexer_Add_DoesExistsInCache_ReplacesValue()
{
// Arrange
var sut = new SynchronizedCache <string, string>();
// Act
sut["key"] = "value";
// Assert
Assert.AreEqual("value", sut["key"]);
}
public void Indexer_Get_DoesNotExistsInCache_ThrowsKeyNotFoundException()
{
// Arrange
var sut = new SynchronizedCache <string, string>();
// Act / Assert
Assert.Throws <KeyNotFoundException>(() =>
{
var unused = sut["key"];
});
}
public void ContainsKey_WhenKeyDoesExists_ReturnsFalse()
{
// Arrange
var sut = new SynchronizedCache <string, string>();
// Act
var exists = sut.ContainsKey("key");
// Assert
Assert.False(exists);
}
public void Item_should_be_removed_on_demand()
{
ICache cache = new PerpetualCache();
cache = new SynchronizedCache(cache);
cache[0] = 0;
Assert.That(cache[0], Is.Not.Null);
cache.Remove(0);
Assert.That(cache[0], Is.Null);
}
public void TryGetValue_WhenItemDoesNotExists_ReturnsFalseAndDefaultValue()
{
// Arrange
var sut = new SynchronizedCache <string, string>();
// Act
var exists = sut.TryGetValue("key", out var result);
// Assert
Assert.False(exists);
Assert.AreEqual(default(string), result);
}
public void Add_WhenItemExistsInCache_ThrowsArgumentException()
{
// Arrange
var sut = new SynchronizedCache <string, string> {
{ "key", "value" }
};
// Act / Assert
var exception = Assert.Throws <ArgumentException>(() => sut.Add("key", "value"));
Assert.AreEqual("An item with the same key has already been added.", exception?.Message);
}
private IStructureDefinition GetStructureDefinition(IMessage theMessage)
{
var messageType = theMessage.GetType();
StructureDefinition retVal;
if (structureDefinitions.TryGetValue(messageType, out var definitions))
{
if (definitions.TryGetValue(theMessage.GetStructureName(), out retVal))
{
return(retVal);
}
}
// Double-Checked Locking
lock (structureDefinitionLock)
{
if (structureDefinitions.TryGetValue(messageType, out var definitions2))
{
if (definitions2.TryGetValue(theMessage.GetStructureName(), out retVal))
{
return(retVal);
}
}
Log.Info($"Instantiating msg of class {messageType.FullName}");
var constructor = messageType.GetConstructor(new[] { typeof(IModelClassFactory) });
var message = (IMessage)constructor.Invoke(new object[] { Factory });
StructureDefinition previousLeaf = null;
retVal = CreateStructureDefinition(message, ref previousLeaf);
if (structureDefinitions.ContainsKey(messageType))
{
return(retVal);
}
#if NET35
var dictionary = new SynchronizedCache <string, StructureDefinition>
{
{ theMessage.GetStructureName(), retVal },
};
#else
var dictionary = new ConcurrentDictionary <string, StructureDefinition>
{
[theMessage.GetStructureName()] = retVal,
};
#endif
structureDefinitions.TryAdd(messageType, dictionary);
}
return(retVal);
}
public void Indexer_Add_DoesNotExistsInCache_AddsValue()
{
// Arrange
var sut = new SynchronizedCache <string, string> {
{ "key", "value" }
};
// Act
sut["key"] = "new value";
// Assert
Assert.AreEqual("new value", sut["key"]);
}
public void TryAdd_WhenItemExistsInCache_DuplicateItemNotAdded()
{
// Arrange
var sut = new SynchronizedCache <string, string>();
sut.TryAdd("key", "value");
// Act
sut.TryAdd("key", "value");
// Assert
Assert.AreEqual(1, sut.Count);
}
public void Indexer_Get_ExistsInCache_ReturnsValue()
{
// Arrange
var sut = new SynchronizedCache <string, string> {
{ "key", "value" }
};
// Act
var result = sut["key"];
// Assert
Assert.AreEqual("value", result);
}
public void ContainsKey_WhenKeyExists_ReturnsTrue()
{
// Arrange
var sut = new SynchronizedCache <string, string> {
{ "key", "value" }
};
// Act
var exists = sut.ContainsKey("key");
// Assert
Assert.True(exists);
}
public void Demonstrate_how_all_objects_are_kept()
{
ICache cache = new PerpetualCache();
cache = new SynchronizedCache(cache);
for (int i = 0; i < 100000; i++)
{
cache[i] = i;
Assert.That(cache[i], Is.EqualTo(i));
}
Assert.That(cache.Size, Is.EqualTo(100000));
}
public void TryGetValue_WhenItemExists_ReturnsTrueAndValue()
{
// Arrange
var sut = new SynchronizedCache <string, string> {
{ "key", "value" }
};
// Act
var exists = sut.TryGetValue("key", out var result);
// Assert
Assert.True(exists);
Assert.AreEqual("value", result);
}
public void Count_ReturnsNumberOfItemsInCache(int numberOfItemsToAdd)
{
// Arrange
var sut = new SynchronizedCache <string, string>();
// Act
for (var i = 0; i < numberOfItemsToAdd; i++)
{
sut.Add($"{i}", "value");
}
// Assert
Assert.AreEqual(numberOfItemsToAdd, sut.Count);
}
public QueryBuilder(IPropertyScope propertyScope)
{
// properties
propertyTypeList = new SynchronizedCache <string, string>();
updateCacheList = new SynchronizedCache <string, string>();
deleteCacheList = new SynchronizedCache <string, string>();
var mappingProperties = propertyScope.GetProperties <T>().Where(p => p.JsonIgnore == false);
var notMapped = mappingProperties.Where(p => p.NotMapped == true).ToArray();
toCreate = mappingProperties.Where(p => p.NotMapped == false).ToList();
toInsert = toCreate.Where(p => p.IsIdentity == false).ToList();
toUpdate = toCreate.Where(p => p.IsKey == false).ToList();
key = toCreate.FirstOrDefault(p => p.IsKey);
// constraints
if (key == null || toCreate.Count(p => p.IsKey) != 1)
{
throw new ArgumentException("QueryBuilder: В классе данных должно быть одно ключевое поле помеченное атрибутом [Key] и без аттрибутов [JsonIgnore] и [NotMapped].");
}
toCreate.ForEach(p =>
{
if (getType(p) == null)
{
throw new ArgumentException($"QueryBuilder: Невозможно определить тип поля {p.Name} в классе {p.Type} в базе данных. Используйте аттрибут [SqlType] для явного указания типа в базе данных.");
}
});
// json properties
jsonSettingsForInsert = new JsonSerializerSettings {
ContractResolver = (key.IsIdentity) ? (new JsonPropertySerializerContractResolver().IgnoreProperty(notMapped).IgnoreProperty(key)) : (new JsonPropertySerializerContractResolver().IgnoreProperty(notMapped))
};
jsonSettingsForUpdate = new JsonSerializerSettings {
ContractResolver = new JsonPropertySerializerContractResolver().IgnoreProperty(notMapped)
};
jsonSettingsForUpdateCacheList = new SynchronizedCache <string, JsonSerializerSettings>();
jsonSettingsForDelete = new JsonSerializerSettings {
ContractResolver = (new JsonPropertySerializerContractResolver().Property(key))
};
jsonSettingsForDeleteCacheList = new SynchronizedCache <string, JsonSerializerSettings>();
// sql queries
createNonClusteredIndexList = new StringBuilder();
GetNonClusteredIndex().ForEach(column => createNonClusteredIndexList.Append($"CREATE NONCLUSTERED INDEX [{column.Name}] ON [dbo].[{GetTable()}] ({string.Join(",", column.Properties.Select(p => $"[{p}] ASC"))}) WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, SORT_IN_TEMPDB = OFF, DROP_EXISTING = OFF, ONLINE = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY];"));
createTable = $"IF OBJECT_ID('[dbo].[{GetTable()}]') IS NULL CREATE TABLE [{GetTable()}] ({string.Join(",", toCreate.Select(p => $"[{p.ColumnName}] {getType(p)} {(p.IsIdentity ? "IDENTITY(1,1)" : string.Empty)} {(p.IsKey || p.IsRequired ? "NOT NULL" : "NULL")}"))}" +
$" CONSTRAINT [PK_{GetTable()}] PRIMARY KEY CLUSTERED ([{key.ColumnName}] ASC) WITH(PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]) ON [PRIMARY]";
truncateTable = $"IF OBJECT_ID('[dbo].[{GetTable()}]') IS NOT NULL TRUNCATE TABLE [{GetTable()}]";
dropTable = $"IF OBJECT_ID('[dbo].[{GetTable()}]') IS NOT NULL DROP TABLE [{GetTable()}]";
insert = $"INSERT INTO [{GetTable()}] ({string.Join(",", toInsert.Select(p => $"[{p.ColumnName}]"))}) SELECT * FROM OPENJSON(@json) WITH ({string.Join(",", toInsert.Select(p => $"[{p.ColumnName}] {getType(p)} '$.{p.JsonProperty}'"))})";
update = $"UPDATE [{GetTable()}] SET {string.Join(",", toUpdate.Select(p => $"[{p.ColumnName}]=source.{p.ColumnName}"))} FROM [{GetTable()}] original JOIN (SELECT * FROM OPENJSON(@json) WITH ({string.Join(",", toCreate.Select(p => $"[{p.ColumnName}] {getType(p)} '$.{p.JsonProperty}'"))})) source ON original.{key.ColumnName}=source.{key.ColumnName}";
delete = $"DELETE original FROM [{GetTable()}] original JOIN (SELECT * FROM OPENJSON(@json) WITH ([{key.ColumnName}] {getType(key)} '$.{key.JsonProperty}')) source ON original.{key.ColumnName}=source.{key.ColumnName}";
}
public void Cache_should_be_clear_on_demand()
{
ICache cache = new PerpetualCache();
cache = new SynchronizedCache(cache);
for (int i = 0; i < 5; i++)
{
cache[i] = i;
}
Assert.That(cache[0], Is.Not.Null);
Assert.That(cache[4], Is.Not.Null);
cache.Clear();
Assert.That(cache[0], Is.Null);
Assert.That(cache[4], Is.Null);
}
public async Task ReadingAndWritingToCache_WhilstNoEnumerations_OnMultipleThreads_DoesNotThrowAnException()
{
// Arrange
var sut = new SynchronizedCache <string, string>();
var tasks = new List <Task>();
for (var i = 0; i < 100; i++)
{
var i1 = i;
tasks.Add(Task.Run(() => sut.TryAdd($"{i1}", "value")));
tasks.Add(Task.Run(() => sut.TryGetValue($"{i1}", out _)));
tasks.Add(Task.Run(() => sut.ContainsKey($"{i1}")));
tasks.Add(Task.Run(() => sut[$"{i1}"] = "value"));
}
// Act
await Task.WhenAll(tasks);
}
public void Enumeration_AttemptToReadWhileEnumerating_ThrowsLockRecursionException()
{
// Arrange
var sut = new SynchronizedCache <string, string>();
for (var i = 0; i < 100; i++)
{
sut.TryAdd($"{i}", "value");
}
// Act
Assert.Throws <LockRecursionException>(() =>
{
foreach (var unused in sut)
{
var dummy = sut["1"];
}
});
}
public static void Main()
{
var sc = new SynchronizedCache();
var tasks = new List <Task>();
int itemsWritten = 0;
// Execute a writer.
tasks.Add(Task.Run(() => { String[] vegetables = { "broccoli", "cauliflower",
"carrot", "sorrel", "baby turnip",
"beet", "brussel sprout",
"cabbage", "plantain",
"spinach", "grape leaves",
"lime leaves", "corn",
"radish", "cucumber",
"raddichio", "lima beans" };
for (int ctr = 1; ctr <= vegetables.Length; ctr++)
{
sc.Add(ctr, vegetables[ctr - 1]);
}
itemsWritten = vegetables.Length;
Console.WriteLine("Task {0} wrote {1} items\n",
Task.CurrentId, itemsWritten); }));
// Execute two readers, one to read from first to last and the second from last to first.
for (int ctr = 0; ctr <= 1; ctr++)
{
bool desc = Convert.ToBoolean(ctr);
tasks.Add(Task.Run(() => { int start, last, step;
int items;
do
{
String output = String.Empty;
items = sc.Count;
if (!desc)
{
start = 1;
step = 1;
last = items;
}
else
{
start = items;
step = -1;
last = 1;
}
for (int index = start; desc?index >= last : index <= last; index += step)
{
output += String.Format("[{0}] ", sc.Read(index));
}
Console.WriteLine("Task {0} read {1} items: {2}\n",
Task.CurrentId, items, output);
} while (items < itemsWritten | itemsWritten == 0); }));
}
// Execute a red/update task.
tasks.Add(Task.Run(() => { Thread.Sleep(100);
for (int ctr = 1; ctr <= sc.Count; ctr++)
{
String value = sc.Read(ctr);
if (value == "cucumber")
{
if (sc.AddOrUpdate(ctr, "green bean") != SynchronizedCache.AddOrUpdateStatus.Unchanged)
{
Console.WriteLine("Changed 'cucumber' to 'green bean'");
}
}
}
}));
// Wait for all three tasks to complete.
Task.WaitAll(tasks.ToArray());
// Display the final contents of the cache.
Console.WriteLine();
Console.WriteLine("Values in synchronized cache: ");
for (int ctr = 1; ctr <= sc.Count; ctr++)
{
Console.WriteLine(" {0}: {1}", ctr, sc.Read(ctr));
}
}
