/// <summary>
/// Deserializes the specified model.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="serializationContext">The serialization context.</param>
public virtual void Deserialize(ModelBase model, TSerializationContext serializationContext)
{
Argument.IsNotNull("model", model);
Argument.IsNotNull("context", serializationContext);
using (var finalContext = GetContext(model, serializationContext, SerializationContextMode.Deserialization))
{
bool?previousLeanAndMeanValue = null;
if (!ModelBase.GlobalLeanAndMeanModel)
{
previousLeanAndMeanValue = model.LeanAndMeanModel;
model.LeanAndMeanModel = true;
}
var serializerModifiers = SerializationManager.GetSerializerModifiers(finalContext.ModelType);
Log.Debug("Using '{0}' serializer modifiers to deserialize type '{1}'", serializerModifiers.Length, finalContext.ModelType.GetSafeFullName());
var serializingEventArgs = new SerializationEventArgs(finalContext);
Deserializing.SafeInvoke(this, serializingEventArgs);
foreach (var serializerModifier in serializerModifiers)
{
serializerModifier.OnDeserializing(finalContext, model);
}
BeforeDeserialization(finalContext);
DeserializeMembers(finalContext);
AfterDeserialization(finalContext);
foreach (var serializerModifier in serializerModifiers)
{
serializerModifier.OnDeserialized(finalContext, model);
}
Deserialized.SafeInvoke(this, serializingEventArgs);
model.FinishDeserialization();
if (previousLeanAndMeanValue.HasValue)
{
model.LeanAndMeanModel = previousLeanAndMeanValue.Value;
}
}
}
/// <summary>
/// Deserializes the specified model.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="context">The serialization context.</param>
protected virtual object Deserialize(object model, ISerializationContext <TSerializationContextInfo> context)
{
Argument.IsNotNull("model", model);
Argument.IsNotNull("context", context);
var serializerModifiers = SerializationManager.GetSerializerModifiers(context.ModelType);
Log.Debug("Using '{0}' serializer modifiers to deserialize type '{1}'", serializerModifiers.Length, context.ModelTypeName);
var serializingEventArgs = new SerializationEventArgs(context);
Deserializing?.Invoke(this, serializingEventArgs);
foreach (var serializerModifier in serializerModifiers)
{
serializerModifier.OnDeserializing(context, model);
}
BeforeDeserialization(context);
var deserializedMemberValues = DeserializeMembers(context);
PopulateModel(context, deserializedMemberValues);
// Always use the deserialized model (might be a value type)
model = context.Model;
AfterDeserialization(context);
foreach (var serializerModifier in serializerModifiers)
{
serializerModifier.OnDeserialized(context, model);
}
Deserialized?.Invoke(this, serializingEventArgs);
return(model);
}
private void OnDeserializing(SerializeEventArgs e)
{
Deserializing?.Invoke(this, e);
}
protected virtual void OnDeserializing(SerializeEventArgs e)
{
Deserializing?.Invoke(this, e);
OnModified(EventArgs.Empty);
}
public void EventDataHandler(object sender, EventDataArg <string> e)
{
Logger.Info($"Invoked EventDataHandler for {e.HostInfo.Host} via {e.HostInfo.Protocol}, message {e.Data}");
IMessage message = Deserializing.GetMessage(e.Data, out MessageType type);
Logger.Debug($"File {message} deserialized to {type} for {e.HostInfo.Host} via {e.HostInfo.Protocol}, message {e.Data}");
if (message == default(IMessage))
{
Logger.Error("Desirializing error");
return;
}
switch (type)
{
case MessageType.Command:
{
CommandMessageReceived?.Invoke(e.HostInfo, new EventCommandMessageArgs(message as CommandMessage));
break;
}
case MessageType.Connect:
{
ConnectMessageReceived?.Invoke(e.HostInfo, new EventMessageConnectArgs(message as ConnectMessage));
break;
}
case MessageType.Request:
{
RequestReceived?.Invoke(e.HostInfo, new EventRequestArgs(message as Request));
break;
}
case MessageType.Telemetry:
{
TelemetryReceived?.Invoke(e.HostInfo, new EventTelemetryArgs(message as Telemetry));
break;
}
case MessageType.Call:
{
CallReceived?.Invoke(e.HostInfo, new EventCallArgs(message as Call));
break;
}
case MessageType.Order:
{
OrderReceived?.Invoke(e.HostInfo, new EventOrderArgs(message as Order));
break;
}
//TODO ВСЕХ НЕВЕРНЫХ СЖЕЧЬ!.. Всмысле, в error
case MessageType.Err:
{
ErrorMessageReceived?.Invoke(e.HostInfo, new EventErrArgs(message as ErrorMessage));
break;
}
default:
Logger.Error("Desirializing error unknow MessageType");
return;
}
}
/// <summary>
/// Triggers the Deserializing event.
/// </summary>
/// <param name="ea">The event arguments.</param>
public virtual void OnDeserializing(SerializingEventArgs ea)
{
Deserializing?.Invoke(this, ea);
}
