public static void UnPackPb()
{
var data = GetData("data.pb");
var stream = new MemoryStream(data);
var ser = new ProtocolSerializer();
var person = ser.Deserialize(stream, null, typeof(Person)) as Person;
stream.Close();
// Console.WriteLine("{0}, {1}, {2}, {3}", person.id, person.name, person.tags.Count, person.logs.Count);
}
public static void OnDataReceived(IClientConnection connection, byte[] data)
{
try
{
ProtocolEncoder encoder = new ProtocolEncoder();
MediumDeserializedObject requestObject = null;
try
{
requestObject = ProtocolSerializer.Deserialize(data);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
string controlCommand = encoder.Decode(requestObject.ControlCommand);
IList <ArraySegment <byte> > serializedResponse = null;
Type requestType = _availableRequests.GetRequestType(controlCommand);
if (requestType != null)
{
try
{
Type protocolRequestInterface = requestType.GetInterfaces().FirstOrDefault(x => typeof(IProtocolRequest <IProtocolResponse>).IsAssignableFrom(x));
Type responseType = protocolRequestInterface.GenericTypeArguments[0];
serializedResponse = (IList <ArraySegment <byte> >)_executeMethod.MakeGenericMethod(requestType, responseType).Invoke(null, new object[] { requestObject.Body });
}
catch
{
serializedResponse = SerializeResponse(new ErrorResponse
{
Code = 500,
Message = "Internal server error."
});
}
}
else
{
serializedResponse = SerializeResponse(new ErrorResponse
{
Code = 400,
Message = "Unsupported request."
});
}
connection.Send(serializedResponse);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
public TResponse Execute <TResponse>(IProtocolRequest <TResponse> request)
where TResponse : class, IProtocolResponse, new()
{
if (_connection == null)
{
throw new ConnectionRequiredException();
}
MessageHeadersDictionary headers = new MessageHeadersDictionary();
byte[] requestHeaders = ProtocolMessageHeaderSerializer.Serialize(headers);
byte[] requestBody = ProtocolBodySerializer.Serialize(request);
byte[] requestIdentifier = _encoder.Encode(request.GetIdentifier());
IList <ArraySegment <byte> > serializedRequest = ProtocolSerializer.Serialize(requestIdentifier, requestHeaders, requestBody);
byte[] responseEncoded = _connection.Send(serializedRequest);
var deserializedObject = ProtocolSerializer.Deserialize(responseEncoded);
string expectedIdentifier = new TResponse().GetIdentifier();
string identifier = _encoder.Decode(deserializedObject.ControlCommand);
if (identifier != expectedIdentifier)
{
if (identifier == ErrorResponse.Identifier)
{
ErrorResponse errorResponse = ProtocolBodySerializer.Deserialize <ErrorResponse>(deserializedObject.Body);
throw new CustomException(errorResponse.Message);
}
throw new InvalidResponseException();
}
TResponse response = ProtocolBodySerializer.Deserialize <TResponse>(deserializedObject.Body);
return(response);
}
/// <summary>
/// Deserializes an execute result.
/// </summary>
/// <param name="bytes">
/// The bytes to deserialize.
/// </param>
/// <returns>The execute result.</returns>
public static IExecuteResult Deserialize(byte[] bytes)
{
return(ProtocolSerializer.Deserialize <SerializableExecuteResult>(bytes));
}
public static IDocumentDescriptor Document([CanBeNull] byte[] bytes)
{
return(bytes == null ? null : ProtocolSerializer.Deserialize <SerializableDocumentDescriptor>(bytes));
}
/// <summary>
/// Initializes a new instance of the <see cref="DocumentUpdatedEventArgs"/> class.
/// </summary>
/// <param name="serializedDocument">The serialized document.</param>
public DocumentUpdatedEventArgs(byte[] serializedDocument)
{
this.Document = ProtocolSerializer.Deserialize <SerializableDocumentDescriptor>(serializedDocument);
}
/// <summary>
/// Deserializes a serialized document.
/// </summary>
/// <param name="serializedDocument">
/// The serialized document.
/// </param>
/// <returns>
/// The <see cref="IDocumentDescriptor"/>.
/// </returns>
public static IDocumentDescriptor Deserialize(byte[] serializedDocument)
{
return(ProtocolSerializer.Deserialize <SerializableDocumentDescriptor>(serializedDocument));
}