/// <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)); }