/// <inheritdoc/>
public T DeserializeObject <T>(byte[] bytes)
{
using (var compress = new DeflateStream(new MemoryStream(bytes), CompressionMode.Decompress))
{
return(_innerSerializer.DeserializeObject <T>(compress));
}
}
public T Get <T>(string key)
{
var conn = _cacheSleeve.GetDatebase();
var redisKey = _cacheSleeve.AddPrefix(key);
if (typeof(T) == typeof(string) || typeof(T) == typeof(byte[]))
{
return((T)(dynamic)conn.StringGet(redisKey));
}
string result;
try
{
result = conn.StringGet(redisKey);
}
catch (Exception)
{
return(default(T));
}
if (result != null)
{
return(_objectSerializer.DeserializeObject <T>(result));
}
return(default(T));
}
/// <summary>
/// Converts the <see cref="HttpResponseMessage"/> into the required data type.
/// </summary>
/// <param name="response">The <see cref="HttpResponseMessage"/>.</param>
/// <param name="dataType">The type to convert to.</param>
/// <param name="serializer">The <see cref="IObjectSerializer"/>.</param>
/// <returns>An object if found; otherwise null.</returns>
public override object ToObject(HttpResponseMessage response, Type dataType, IObjectSerializer serializer)
{
var content = response.Content.ReadAsStringAsync().Result;
if (content.IsNullOrEmpty() == true)
{
return(null);
}
object model = serializer.DeserializeObject(content, this.ModelType);
if (model == null)
{
return(null);
}
var property = this.ModelType.GetProperty(this.PropertyName);
if (property == null)
{
throw new InvalidOperationException($"Property not found on model {this.ModelType.Name}");
}
if (dataType.IsAssignableFrom(property.PropertyType) == false)
{
throw new InvalidCastException($"Cannot cast {property.PropertyType} to {dataType.Name}");
}
return(property.GetValue(model));
}
private FunctionCallResponseMessage WaitForResponseMessageFromServer()
{
var responseStr = _streamReader.ReadLine();
var responseMessage = _serializer.DeserializeObject <FunctionCallResponseMessage>(responseStr);
return(responseMessage);
}
public async Task <FilterResult> Filter(FilterDescriptor filterDescriptor)
{
FilterDefinitionBuilder <BsonDocument> filterBuilder = Builders <BsonDocument> .Filter;
IFindFluent <BsonDocument, BsonDocument> findFluent = null;
if (filterDescriptor.Filters.Any())
{
FilterDefinition <BsonDocument> filterDefinition = null;
switch (filterDescriptor.Logic)
{
case FilteringLogic.All:
filterDefinition = filterBuilder.And(filterDescriptor.Filters.Select(filter => ParseFilter(filter)));
break;
case FilteringLogic.Any:
filterDefinition = filterBuilder.Or(filterDescriptor.Filters.Select(filter => ParseFilter(filter)));
break;
default:
throw new NotSupportedException();
}
findFluent = _collection.Find(filterDefinition);
}
else
{
findFluent = _collection.Find(_ => true);
}
if (filterDescriptor.Limit.HasValue)
{
findFluent.Limit(filterDescriptor.Limit.Value);
}
if (filterDescriptor.Offset.HasValue)
{
findFluent.Skip(filterDescriptor.Offset.Value);
}
try
{
List <BsonDocument> result = await findFluent.ToListAsync();
long total = await findFluent.CountAsync();
return(new FilterResult(
result.Select(item => (DeviceDescriptor)_serializer.DeserializeObject(item.ToJson(jsonWriterSettings), typeof(DeviceDescriptor))).ToArray(),
total));
}
catch (Exception ex)
{
throw new DeviceRepositoryException("Cannot get devices from database.", ex);
}
}
/// <summary>
/// Converts the given <see cref="HttpResponseMessage"/> into the required type.
/// </summary>
/// <param name="response">The <see cref="HttpResponseMessage"/>.</param>
/// <param name="dataType">The required type.</param>
/// <param name="serializer">A <see cref="IObjectSerializer"/> for the responses contnet type.</param>
/// <returns>An instance of the type; otherwise null.</returns>
public virtual object ToObject(HttpResponseMessage response, Type dataType, IObjectSerializer serializer)
{
var content = response.Content.ReadAsStringAsync().Result;
if (content.IsNullOrEmpty() == true)
{
return(null);
}
Type objectType = this.ReturnType ?? dataType;
object model = serializer.DeserializeObject(content, objectType);
if (model == null)
{
return(null);
}
return(model);
}
private void RequestProcessingLoop(TcpClient tcpClient, StreamReader streamReader, StreamWriter streamWriter)
{
var shouldStop = false;
while (tcpClient.Connected && !shouldStop)
{
_cancellationToken.ThrowIfCancellationRequested();
var requestString = WaitForClientRequest(streamReader);
if (string.IsNullOrEmpty(requestString))
{
shouldStop = true;
}
else
{
var functionCallMessage = _serializer.DeserializeObject <FunctionCallMessage>(requestString);
var methodInfo = GetMethodInfo(functionCallMessage);
using (var functionCallResult = ExecuteMethodCallOnDispatcher(methodInfo, functionCallMessage))
{
if (functionCallResult.DidSucceed)
{
if (IsBulky(functionCallResult.ReturnValue))
{
HandleBulk(functionCallResult.ReturnValue, streamWriter, streamReader);
}
else
{
HandleNonBulk(functionCallResult.ReturnValue, streamWriter);
}
}
else
{
HandleException(functionCallResult.ExceptionMessage, streamWriter);
}
} //functionCallResult can and is guaranteed to be disposed. All bytes have been sent to client via TCP...
}
}
}
private void ReceiveMessageHandler(byte[] data, PerChannelID id)
{
Logger.Log("Received packet!");
PacketSubscribers?.Invoke(_serializer.DeserializeObject(data), GetConnection(id, false));
}
public void DeserializeObject_ShouldHandleInt()
{
Assert.That(_serializer.DeserializeObject("1"), Is.EqualTo(1));
}
private void ReceiveMessageHandler(byte[] data)
{
Logger.Log("Received packet!");
PacketSubscribers?.Invoke(_serializer.DeserializeObject(data));
}
