object IRedisValueConverter <object> .FromRedisValue(StackRedis.RedisValue value, string valueType)
{
if (valueType == ByteArrayType.AssemblyQualifiedName)
{
var converter = (IRedisValueConverter <byte[]>) this;
return(converter.FromRedisValue(value, valueType));
}
else if (valueType == StringType.AssemblyQualifiedName)
{
var converter = (IRedisValueConverter <string>) this;
return(converter.FromRedisValue(value, valueType));
}
else if (valueType == IntType.AssemblyQualifiedName)
{
var converter = (IRedisValueConverter <int>) this;
return(converter.FromRedisValue(value, valueType));
}
else if (valueType == DoubleType.AssemblyQualifiedName)
{
var converter = (IRedisValueConverter <double>) this;
return(converter.FromRedisValue(value, valueType));
}
else if (valueType == BoolType.AssemblyQualifiedName)
{
var converter = (IRedisValueConverter <bool>) this;
return(converter.FromRedisValue(value, valueType));
}
else if (valueType == LongType.AssemblyQualifiedName)
{
var converter = (IRedisValueConverter <long>) this;
return(converter.FromRedisValue(value, valueType));
}
return(this.Deserialize(value, valueType));
}
object IRedisValueConverter <object> .FromRedisValue(StackRedis.RedisValue value, string valueType)
{
if (valueType == ByteArrayType.FullName)
{
var converter = (IRedisValueConverter <byte[]>) this;
return(converter.FromRedisValue(value, valueType));
}
else if (valueType == StringType.FullName)
{
var converter = (IRedisValueConverter <string>) this;
return(converter.FromRedisValue(value, valueType));
}
else if (valueType == IntType.FullName)
{
var converter = (IRedisValueConverter <int>) this;
return(converter.FromRedisValue(value, valueType));
}
else if (valueType == DoubleType.FullName)
{
var converter = (IRedisValueConverter <double>) this;
return(converter.FromRedisValue(value, valueType));
}
else if (valueType == BoolType.FullName)
{
var converter = (IRedisValueConverter <bool>) this;
return(converter.FromRedisValue(value, valueType));
}
else if (valueType == LongType.FullName)
{
var converter = (IRedisValueConverter <long>) this;
return(converter.FromRedisValue(value, valueType));
}
return(FromBytes <object>(value));
}
private object Deserialize(StackRedis.RedisValue value, string valueType)
{
var type = this.GetType(valueType);
EnsureNotNull(type, "Type could not be loaded, {0}.", valueType);
return(this.serializer.Deserialize(value, type));
}
static string getTokenDetails(string Key)
{
Redis.ConnectionMultiplexer connection = Redis.ConnectionMultiplexer.Connect("localhost,password=ZLDe3wse");
Redis.IDatabase db = connection.GetDatabase();
Redis.RedisValue Value = db.StringGet(Key);
return(Value);
}
static void WriteToCache(string Key, string Value, DateTime expires)
{
var expiryTimeSpan = expires.Subtract(DateTime.Now);
if (expiryTimeSpan.Ticks < 0)
{
Console.WriteLine("Cannot set negative TTL value for the Key:{0} and Value:{0}", Key, Value);
}
else
{
Redis.RedisValue val = db.StringSet(Key, Value, expiryTimeSpan);
}
}
private TCacheValue FromRedisValue(StackRedis.RedisValue value, string valueType)
{
if (value.IsNull || value.IsNullOrEmpty || !value.HasValue)
{
return(default(TCacheValue));
}
var typedConverter = this.valueConverter as IRedisValueConverter <TCacheValue>;
if (typedConverter != null)
{
return(typedConverter.FromRedisValue(value, valueType));
}
return(this.valueConverter.FromRedisValue <TCacheValue>(value, valueType));
}
public void ListRightPush(string list_key, List <AVEHICLE> values)
{
IDatabase db = Database();
if (db == null)
{
return;
}
StackExchange.Redis.RedisValue[] redisArray = new StackExchange.Redis.RedisValue[values.Count];
for (int i = 0; i < values.Count; i++)
{
redisArray[i] = values[i].ToString();
}
list_key = $"{productID}_{list_key}";
Task taskSand = db.ListRightPushAsync(list_key, redisArray);
UsingCount();
//taskSand.Wait();
}
object IRedisValueConverter <object> .FromRedisValue(StackRedis.RedisValue value, string type)
{
var valueType = this.GetType(type);
if (valueType == ByteArrayType)
{
var converter = (IRedisValueConverter <byte[]>) this;
return(converter.FromRedisValue(value, type));
}
else if (valueType == StringType)
{
var converter = (IRedisValueConverter <string>) this;
return(converter.FromRedisValue(value, type));
}
else if (valueType == IntType)
{
var converter = (IRedisValueConverter <int>) this;
return(converter.FromRedisValue(value, type));
}
else if (valueType == DoubleType)
{
var converter = (IRedisValueConverter <double>) this;
return(converter.FromRedisValue(value, type));
}
else if (valueType == BoolType)
{
var converter = (IRedisValueConverter <bool>) this;
return(converter.FromRedisValue(value, type));
}
else if (valueType == LongType)
{
var converter = (IRedisValueConverter <long>) this;
return(converter.FromRedisValue(value, type));
}
return(this.Deserialize(value, type));
}
public static Message Create(int db, CommandFlags flags, RedisCommand command, RedisValue value0, RedisValue value1, RedisValue value2, RedisValue value3, RedisValue value4)
{
return(new CommandValueValueValueValueValueMessage(db, flags, command, value0, value1, value2, value3, value4));
}
public T FromRedisValue <T>(StackRedis.RedisValue value, string valueType) => (T)this.Deserialize(value, valueType);
public CommandChannelValueMessage(int db, CommandFlags flags, RedisCommand command, RedisChannel channel, RedisValue value) : base(db, flags, command, channel)
{
value.AssertNotNull();
this.value = value;
}
long IRedisValueConverter <long> .FromRedisValue(StackRedis.RedisValue value, string valueType) => (long)value;
byte IRedisValueConverter <byte> .FromRedisValue(StackRedis.RedisValue value, string valueType) => (byte)value;
private bool Set(CacheItem <TCacheValue> item, StackRedis.When when, bool sync = false)
{
if (!this.isLuaAllowed)
{
return(this.SetNoScript(item, when, sync));
}
var fullKey = GetKey(item.Key, item.Region);
var value = this.ToRedisValue(item.Value);
var flags = sync ? StackRedis.CommandFlags.None : StackRedis.CommandFlags.FireAndForget;
// ARGV [1]: value, [2]: type, [3]: expirationMode, [4]: expirationTimeout(millis), [5]: created(ticks)
var parameters = new StackRedis.RedisValue[]
{
value,
item.ValueType.AssemblyQualifiedName,
(int)item.ExpirationMode,
item.ExpirationTimeout.TotalMilliseconds,
item.CreatedUtc.Ticks
};
StackRedis.RedisResult result;
if (when == StackRedis.When.NotExists)
{
result = this.Eval(ScriptType.Add, fullKey, parameters, flags);
}
else
{
result = this.Eval(ScriptType.Put, fullKey, parameters, flags);
}
if (result == null)
{
if (flags.HasFlag(StackRedis.CommandFlags.FireAndForget))
{
// put runs via fire and forget, so we don't get a result back
return(true);
}
// should never happen, something went wrong with the script
throw new InvalidOperationException("Something went wrong adding an item, result must not be null.");
}
else
{
if (result.IsNull && when == StackRedis.When.NotExists)
{
// add failed because element exists already
return(false);
}
var resultValue = (StackRedis.RedisValue)result;
if (resultValue.HasValue && resultValue.ToString().Equals("OK", StringComparison.OrdinalIgnoreCase))
{
// Added successfully:
if (!string.IsNullOrWhiteSpace(item.Region))
{
// now update region lookup if region is set
// we cannot do that within the lua because the region could be on another cluster node!
this.connection.Database.HashSet(item.Region, fullKey, "regionKey", when, StackRedis.CommandFlags.FireAndForget);
}
return(true);
}
return(false);
}
}
double IRedisValueConverter <double> .FromRedisValue(StackRedis.RedisValue value, string valueType) => (double)value;
bool IRedisValueConverter <bool> .FromRedisValue(StackRedis.RedisValue value, string valueType)
{
return((bool)value);
}
ulong IRedisValueConverter <ulong> .FromRedisValue(StackRedis.RedisValue value, string valueType) => ulong.Parse(value);
double IRedisValueConverter <double> .FromRedisValue(StackRedis.RedisValue value, string valueType)
{
return((double)value);
}
float IRedisValueConverter <float> .FromRedisValue(StackRedis.RedisValue value, string valueType) => (float)(double)value;
ushort IRedisValueConverter <ushort> .FromRedisValue(StackRedis.RedisValue value, string valueType) => (ushort)value;
byte[] IRedisValueConverter <byte[]> .FromRedisValue(StackRedis.RedisValue value, string valueType) => value;
public static Message Create(int db, CommandFlags flags, RedisCommand command, RedisValue value, RedisKey key)
{
return(new CommandValueKeyMessage(db, flags, command, value, key));
}
int IRedisValueConverter <int> .FromRedisValue(StackRedis.RedisValue value, string valueType) => (int)value;
public CommandKeyValueValueValueMessage(int db, CommandFlags flags, RedisCommand command, RedisKey key, RedisValue value0, RedisValue value1, RedisValue value2) : base(db, flags, command, key)
{
value0.AssertNotNull();
value1.AssertNotNull();
value2.AssertNotNull();
this.value0 = value0;
this.value1 = value1;
this.value2 = value2;
}
bool IRedisValueConverter <bool> .FromRedisValue(StackRedis.RedisValue value, string valueType) => (bool)value;
public CommandKeyValueMessage(int db, CommandFlags flags, RedisCommand command, RedisKey key, RedisValue value) : base(db, flags, command, key)
{
value.AssertNotNull();
this.value = value;
}
string IRedisValueConverter <string> .FromRedisValue(StackRedis.RedisValue value, string valueType)
{
return(value);
}
char IRedisValueConverter <char> .FromRedisValue(StackRedis.RedisValue value, string valueType) => (char)value;
int IRedisValueConverter <int> .FromRedisValue(StackRedis.RedisValue value, string valueType)
{
return((int)value);
}
public static Message Create(int db, CommandFlags flags, RedisCommand command, RedisKey key, RedisValue value0, RedisValue value1, RedisValue value2, RedisValue value3)
{
return(new CommandKeyValueValueValueValueMessage(db, flags, command, key, value0, value1, value2, value3));
}
