public override async Task WriteAsync(RedisConvert convert, Type objectType, object value, Namespace name, TimeSpan?TTL = null)
{
//Convert to string and then write it to the converter
await convert.WriteValueAsync(name, value.ToString(), TTL);
return;
}
public override async Task <object> ReadAsync(RedisConvert convert, Type objectType, object existingValue, Namespace name)
{
//Make sure the type is valid.
var types = objectType.GetGenericArguments();
Debug.Assert(types.Length == 1);
if (!types[0].IsPrimitive && !types[0].IsEnum)
{
throw new ArgumentException("HashSet type is invalid. Only primitive HashSets are supported.", "value");
}
//Get the hashset
HashSet <string> hashset = await convert.Client.FetchHashSetAsync(name.Build());
//Prepare a hashset of the new type
var existingSet = existingValue;
if (existingValue == null)
{
existingSet = Activator.CreateInstance(objectType);
}
//Prepare the add function
var add = objectType.GetMethod("Add");
//Iterate over every value in the hashset adding it to the new hashset
foreach (var s in hashset)
{
object val = TypeDescriptor.GetConverter(types[0]).ConvertFromString(s);
add.Invoke(existingSet, new object[] { val });
}
return(existingSet);
}
public override async Task WriteAsync(RedisConvert convert, Type objectType, object value, Namespace name, TimeSpan?TTL = null)
{
//Prepare the options
RedisOptionAttribute options = objectType.GetCustomAttribute <RedisOptionAttribute>();
if (options == null)
{
options = new RedisOptionAttribute();
}
//Store it as a simple string
if (options.SingleValueKey)
{
await convert.Client.StoreStringAsync(name.Build(), value.ToString(), TTL);
return;
}
//The content that will be written to the HashMap in bulk
Dictionary <string, string> hashmap = new Dictionary <string, string>();
//Iterate over every property
foreach (var property in objectType.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
{
var ignoreAttribute = property.GetCustomAttribute <RedisIgnoreAttribute>();
if (ignoreAttribute != null)
{
continue;
}
//Prepare some property values
var propertyName = property.Name;
var propertyAttribute = property.GetCustomAttribute <RedisPropertyAttribute>();
if (propertyAttribute != null)
{
propertyName = propertyAttribute.DisplayName ?? property.Name;
}
//Prepare the serializer
var serializer = convert.GetSerializerForType(property.PropertyType, property: propertyAttribute);
Debug.Assert(serializer != null);
//Push the name and then serialize it
name.Push(propertyName);
convert.SetHashMapBuffer(hashmap);
await serializer.WriteAsync(convert, property.PropertyType, property.GetValue(value), name, TTL);
name.Pop();
}
//Flush our buffer
convert.SetHashMapBuffer(hashmap);
await convert.FlushHashMapAsync(name, TTL);
}
public override async Task <object> ReadAsync(RedisConvert convert, Type objectType, object existingValue, Namespace name)
{
//Get the current string value
string value = await convert.Client.FetchStringAsync(name.Build(), null);
if (value == null)
{
return(existingValue);
}
//If we are a primitive or enum then convert it from string and return the value
if (objectType.IsPrimitive || objectType.IsEnum)
{
return(TypeDescriptor.GetConverter(objectType).ConvertFromString(value));
}
//Return the raw string value.
return(value);
}
public override async Task WriteAsync(RedisConvert convert, Type objectType, object value, Namespace name, TimeSpan?TTL = null)
{
//Prepare the map. If we are already the correct type just use the raw value,
// otherwise we will convert it to the correct type.
Dictionary <string, string> map = null;
if (objectType == typeof(Dictionary <string, string>))
{
map = (Dictionary <string, string>)value;
}
else
{
//Get the generic types and make sure they are valid
var genericTypes = objectType.GetGenericArguments();
Debug.Assert(genericTypes.Length == 2);
if ((!genericTypes[0].IsPrimitive && !genericTypes[0].IsEnum) || (!genericTypes[1].IsPrimitive && !genericTypes[1].IsEnum))
{
throw new ArgumentException("Dictionary type is invalid. Only primitive Dictionaries are supported.", "value");
}
//Get the enumerator for the dictionary ( value.GetEnumerator(); )
var getEnumerator = objectType.GetMethod("GetEnumerator");
var enumerator = (IEnumerator)getEnumerator.Invoke(value, null);
//Get the properties of the keypairs
var keypairType = typeof(KeyValuePair <,>).MakeGenericType(genericTypes);
var keyProperty = keypairType.GetProperty("Key");
var valueProperty = keypairType.GetProperty("Value");
//Iterate over every item and add them to the map
while (enumerator.MoveNext())
{
var kp_key = keyProperty.GetValue(enumerator.Current);
var kp_value = valueProperty.GetValue(enumerator.Current);
map[kp_key.ToString()] = kp_value.ToString();
}
}
//Store the map in Redis
await convert.WriteHashMapAsync(name, map, TTL);
}
public override async Task WriteAsync(RedisConvert convert, Type objectType, object value, Namespace name, TimeSpan?TTL = null)
{
//Prepare the hashset we will copy into
HashSet <string> hashset = null;
if (objectType == typeof(HashSet <string>))
{
hashset = (HashSet <string>)value;
}
else
{
var types = objectType.GetGenericArguments();
Debug.Assert(types.Length == 1);
//Make sure the type is valid.
if (!types[0].IsPrimitive && !types[0].IsEnum)
{
throw new ArgumentException("HashSet type is invalid. Only primitive HashSets are supported.", "value");
}
//Prepare the set
hashset = new HashSet <string>();
//Fetch the enumerator
var getEnumerator = objectType.GetMethod("GetEnumerator");
var enumerator = (IEnumerator)getEnumerator.Invoke(value, null);
//Iterate over every element converting them to a string and adding them to our set
while (enumerator.MoveNext())
{
hashset.Add(enumerator.Current.ToString());
}
}
//Write to the DB
await convert.WriteHashSetAsync(name, hashset, TTL, true);
}
public override Task <object> ReadAsync(RedisConvert convert, Type objectType, object existingValue, Namespace name)
{
throw new NotImplementedException();
}
public override Task WriteAsync(RedisConvert convert, Type objectType, object value, Namespace name, TimeSpan?TTL = null)
{
throw new NotImplementedException();
}
public abstract Task WriteAsync(RedisConvert convert, Type objectType, object value, Namespace name, TimeSpan?TTL = null);
public abstract Task <object> ReadAsync(RedisConvert convert, Type objectType, object existingValue, Namespace name);
