static Task LaneCaching()
{
return(Task.WhenAll(Enumerable.Range(0, Sockets).Select(async x =>
{
var builder = new ClientBuilder().UseSockets().Build();
var connection = builder.ConnectAsync(new IPEndPoint(IPAddress.Parse(Destination), 11211)).GetAwaiter().GetResult();
await using (var client = new MemcachedProtocol(new LowLatencyMessageProtocol <MemcachedRequest, IMemcachedResponse>(connection, new MemcachedMessageWriter(), new MemcachedMessageReader())))
{
client.Start();
var list = new List <Task>();
for (var i = 0; i < Threads; i++)
{
list.Add(Task.Run(async() => {
await client.Set(Key, Value, null);
foreach (var batch in Enumerable.Range(0, Iterations).Batch(200))
{
await Task.WhenAll(batch.Select(x =>
client.Get <string, StringResponseDeserializer>(Key,
new StringResponseDeserializer())));
}
}));
}
await Task.WhenAll(list);
}
})));
}
private static async Task MemcachedProtocol(IServiceProvider serviceProvider)
{
var loggerFactory = LoggerFactory.Create(builder =>
{
builder.SetMinimumLevel(LogLevel.Error);
builder.AddConsole();
});
var client = new ClientBuilder(serviceProvider)
.UseSockets()
.UseConnectionLogging(loggerFactory: loggerFactory)
.Build();
var ipAddress = IPAddress.Parse("127.0.0.1");
var connection = await client.ConnectAsync(new IPEndPoint(ipAddress, 11211));
MemcachedProtocol memcachedProtocol = new MemcachedProtocol(connection);
await memcachedProtocol.Set("Hello", Encoding.UTF8.GetBytes("World"), TimeSpan.FromMinutes(30));
var checkSet = await memcachedProtocol.Get("Hello");
Console.WriteLine($"checkSet result :{Encoding.UTF8.GetString(checkSet)}");
await memcachedProtocol.Replace("Hello", Encoding.UTF8.GetBytes("World replaced"), TimeSpan.FromMinutes(30));
var checkReplace = await memcachedProtocol.Get("Hello");
Console.WriteLine($"checkReplace result :{Encoding.UTF8.GetString(checkReplace)}");
}
public async Task SetAndGetValue()
{
var builder = new ClientBuilder().UseSockets().Build();
await using var connection = await builder.ConnectAsync(TestConstants.MemcachedServer);
await using var client = new MemcachedProtocol(new LowLatencyMessageProtocol <MemcachedRequest, IMemcachedResponse>(connection, new MemcachedMessageWriter(), new MemcachedMessageReader()));
client.Start();
await client.Set("key", "value", null);
var value = await client.Get <string, StringResponseDeserializer>("key", new StringResponseDeserializer());
Assert.Equal("value", value);
}
public async Task DeleteAKey()
{
var builder = new ClientBuilder().UseSockets().Build();
await using var connection = await builder.ConnectAsync(TestConstants.MemcachedServer);
await using var client = new MemcachedProtocol(new LowLatencyMessageProtocol <MemcachedRequest, IMemcachedResponse>(connection, new MemcachedMessageWriter(), new MemcachedMessageReader()));
client.Start();
var key = "ToDelete";
await client.Set(key, "value", null);
var value = await client.Get <string, StringResponseDeserializer>(key, new StringResponseDeserializer());
Assert.Equal("value", value);
await client.Delete(key);
await Assert.ThrowsAsync <KeyNotFoundException>(() => client.Get <string, StringResponseDeserializer>(key, new StringResponseDeserializer()));
}
public async Task ReplaceValue()
{
var builder = new ClientBuilder().UseSockets().Build();
await using var connection = await builder.ConnectAsync(TestConstants.MemcachedServer);
await using var client = new MemcachedProtocol(new LowLatencyMessageProtocol <MemcachedRequest, IMemcachedResponse>(connection, new MemcachedMessageWriter(), new MemcachedMessageReader()));
client.Start();
var key = "ToReplace";
await client.Set(key, "firstValue", null);
var value = await client.Get <string, StringResponseDeserializer>(key, new StringResponseDeserializer());
Assert.Equal("firstValue", value);
await client.Replace(new StringWritable(key), new StringWritable("newValue"), null);
var replaced = await client.Get <string, StringResponseDeserializer>(key, new StringResponseDeserializer());
Assert.Equal("newValue", replaced);
}
private async Task RunLaneCache(Func <ConnectionContext, IMessageProtocol <MemcachedRequest, IMemcachedResponse> > protocol)
{
var builder = new ClientBuilder().UseSockets().Build();
var connection = await builder.ConnectAsync(new IPEndPoint(IPAddress.Parse("10.0.0.21"), 11211));
await using var client = new MemcachedProtocol(protocol(connection));
client.Start();
var list = new List <Task>();
for (var i = 0; i < Threads; i++)
{
list.Add(Task.Run(async() => {
await client.Set(Key, Value, null);
foreach (var batch in Enumerable.Range(0, Iterations).Batch(200))
{
await Task.WhenAll(batch.Select(x =>
client.Get <string, StringResponseDeserializer>(Key,
new StringResponseDeserializer())));
}
}));
}
await Task.WhenAll(list);
}
public async Task ExpireQuickly()
{
var builder = new ClientBuilder().UseSockets().Build();
await using var connection = await builder.ConnectAsync(TestConstants.MemcachedServer);
await using var client = new MemcachedProtocol(new LowLatencyMessageProtocol <MemcachedRequest, IMemcachedResponse>(connection, new MemcachedMessageWriter(), new MemcachedMessageReader()));
client.Start();
var key = "ToExpire";
var expirationTime = TimeSpan.FromSeconds(2);
await client.Set(key, "firstValue", expirationTime);
var value = await client.Get <string, StringResponseDeserializer>(key, new StringResponseDeserializer());
Assert.Equal("firstValue", value);
// memcached expires entries on 1-second boundaries, so setting this to n+1 seconds expiration may cause the test to fail some of the time
await Task.Delay(expirationTime.Add(TimeSpan.FromSeconds(2)));
await Assert.ThrowsAsync <KeyNotFoundException>(() => client.Get <string, StringResponseDeserializer>(key, new StringResponseDeserializer()));
}
