private void cbMessages_SelectedIndexChanged(object sender, EventArgs e)
{
SbeMessage message = SbeLoader.LoadMessageByName(cbMessages.Text);
if (message != null)
{
tree.BeginUpdate();
lblDescription.Text = "Description: " + message.Description;
lblId.Text = "ID: " + message.Id;
_Message.Clear();
_Message.Add(message);
if (checkBox1.Checked)
{
CreateHeader();
}
tree.Roots = _Message;
tree.ExpandAll();
tree.AutoResizeColumns(ColumnHeaderAutoResizeStyle.ColumnContent);
colValue.Width = 100;
tree.EndUpdate();
}
else
{
lblDescription.Text = "Description:";
lblId.Text = "ID:";
tree.Clear();
}
}
public static void Load(string file)
{
XmlReaderSettings settings = new XmlReaderSettings {
NameTable = new NameTable(), DtdProcessing = DtdProcessing.Ignore
};
XmlNamespaceManager xmlns = new XmlNamespaceManager(settings.NameTable);
xmlns.AddNamespace("sbe", "http://fixprotocol.io/2016/sbe");
XmlParserContext context = new XmlParserContext(null, xmlns, "", XmlSpace.Default);
XmlReader reader = XmlReader.Create(file, settings, context);
xml.Load(reader);
XmlNodeList enums = xml.SelectNodes("//*[local-name()='enum']");
if (enums.Count > 0)
{
foreach (XmlNode node in enums)
{
SbeEnum sbeenum = new SbeEnum(node);
_Enums.Add(sbeenum);
}
}
XmlNodeList types = xml.SelectNodes("//*[local-name()='types']/*[local-name()='type']");
if (types.Count > 0)
{
foreach (XmlNode node in types)
{
SbeType type = new SbeType(node);
_SimpleTypes.Add(type);
}
}
XmlNodeList composites = xml.SelectNodes("//*[local-name()='composite']");
if (composites.Count > 0)
{
foreach (XmlNode node in composites)
{
SbeCompositeType composite = new SbeCompositeType(node);
_CompositeTypes.Add(composite);
}
}
XmlNodeList msgs = xml.SelectNodes("//*[local-name()='message']");
if (msgs.Count > 0)
{
foreach (XmlNode node in msgs)
{
// <sbe:message name="NegotiateResponse" id="2" description="Negotiate Response message">
SbeMessage msg = new SbeMessage(node);
_Messages.Add(msg.Name);
}
}
}
private void CreateHeader()
{
SbeMessage mh = new SbeMessage();
mh.Name = "Message Header";
SbeField f = new SbeField();
f.Name = "blockLength";
f.Length = 2;
f.Type = "uint16";
f.PrimitiveType = "uint16";
f.Offset = 0;
f.Presence = "";
mh.Fields.Insert(0, f);
SbeField f2 = new SbeField();
f2.Name = "TemplateId";
f2.Length = 2;
f2.Type = "uint16";
f2.PrimitiveType = "uint16";
f2.Offset = 2;
f2.Presence = "";
f2.Value = _Message[0].Id;
mh.Fields.Insert(1, f2);
SbeField f3 = new SbeField();
f3.Name = "SchemaId";
f3.Length = 2;
f3.Type = "uint16";
f3.PrimitiveType = "uint16";
f3.Offset = 4;
f3.Presence = "";
mh.Fields.Insert(2, f3);
SbeField f4 = new SbeField();
f4.Name = "Version";
f4.Length = 2;
f4.Type = "uint16";
f4.PrimitiveType = "uint16";
f4.Offset = 6;
f4.Presence = "";
mh.Fields.Insert(3, f4);
_Message.Insert(0, mh);
}
public static SbeMessage LoadMessageById(string id)
{
XmlNodeList msgs = xml.SelectNodes("//*[local-name()='message']");
if (msgs.Count > 0)
{
foreach (XmlNode node in msgs)
{
// <sbe:message name="NegotiateResponse" id="2" description="Negotiate Response message">
SbeMessage msg = new SbeMessage(node);
if (msg.Id.ToLower().Equals(id))
{
return(msg);
}
}
}
return(null);
}
public static SbeMessage LoadMessageByName(string messageName)
{
if (_Messages.Find(x => x == messageName) != null)
{
XmlNodeList msgs = xml.SelectNodes("//*[local-name()='message']");
if (msgs.Count > 0)
{
foreach (XmlNode node in msgs)
{
SbeMessage msg = new SbeMessage(node);
if (msg.Name.ToLower().Equals(messageName.ToLower()))
{
return(msg);
}
}
}
}
return(null);
}
public String DecodeSBEMessageQATEngine(byte[] MessageBytes)
{
StringBuilder sb = new StringBuilder();
var directBuffer = new DirectBuffer(MessageBytes);
int bufferOffset = 0;
ushort blockLength = directBuffer.Uint16GetLittleEndian(bufferOffset);
bufferOffset += 2;
sb.AppendLine(CrackHelper.CreateLine("Header", "BlockLength", blockLength.ToString()));
ushort templateId = directBuffer.Uint16GetLittleEndian(bufferOffset);
bufferOffset += 2;
sb.AppendLine(CrackHelper.CreateLine("Header", "TemplateId", templateId.ToString()));
ushort schemaId = directBuffer.Uint16GetLittleEndian(bufferOffset);
bufferOffset += 2;
sb.AppendLine(CrackHelper.CreateLine("Header", "SchemaId", schemaId.ToString()));
ushort version = directBuffer.Uint16GetLittleEndian(bufferOffset);
bufferOffset += 2;
sb.AppendLine(CrackHelper.CreateLine("Header", "Version", version.ToString()));
SbeMessage Message = SbeLoader.LoadMessageById(templateId.ToString());
if (Message == null)
{
throw new Exception("Message not recognized! TemplateId = " + templateId.ToString());
}
foreach (SbeField field in Message.Fields)
{
FillValue(directBuffer, field, ref bufferOffset);
}
sb.Append(Message.Crack());
return(sb.ToString());
}
public static SbeField GetField(Assembly assembly, SbeField field, String MessageName, object MessageBody)
{
if (SbeLoader._Enums.Find(x => x.Name == field.Type) != null)
{
#region Enumeration
GetEnumerationField(assembly, field, MessageBody, MessageName);
#endregion
}
else if (SbeLoader._SimpleTypes.Find(x => x.Name == field.Type) != null)
{
#region Simple Type
if (field.Presence.Contains("constant"))
{
return(field);
}
//SimpleType
SbeType simple = SbeLoader._SimpleTypes.Find(x => x.Name == field.Type);
if (simple.PrimitiveType.ToLower().Equals("char"))
{
FieldInfo l = ReflectionHelper.GetFieldByName(assembly, MessageName, field.Name + "Length");
int length = (int)l.GetValue(MessageBody);
var fieldByte = new byte[length];
MethodInfo mi = ReflectionHelper.GetMethodByName(assembly, MessageName, "Get" + field.Name, "byte[]");
mi.Invoke(MessageBody, new object[] { fieldByte, 0 }).ToString();
FieldInfo fi = ReflectionHelper.GetFieldByName(assembly, MessageName, field.Name + "CharacterEncoding");
string enc = fi.GetValue(MessageBody).ToString();
field.Value = Encoding.GetEncoding(enc).GetString(fieldByte, 0, length);
}
else
{
PropertyInfo pi = ReflectionHelper.GetPropertyByName(assembly, MessageName, field.Name);
field.Value = Convert.ChangeType(pi.GetValue(MessageBody), pi.PropertyType).ToString();
}
#endregion
}
else if (SbeLoader._CompositeTypes.Find(x => x.Name == field.Type) != null)
{
#region Composite
if (field.Type.ToLower().Equals("groupsizeencoding"))
{
#region groupsizeencoding
//var fuelFiguresGroup = car.FuelFigures;
//while (fuelFiguresGroup.HasNext)
//{
//var fuelFigures = fuelFiguresGroup.Next();
//sb.Append("\ncar.fuelFigures.speed=").Append(fuelFigures.Speed);
//sb.Append("\ncar.fuelFigures.mpg=").Append(fuelFigures.Mpg);
//}
PropertyInfo no = ReflectionHelper.GetPropertyByName(assembly, MessageName, field.Name);
var repeat = no.GetValue(MessageBody);
PropertyInfo hasNext = ReflectionHelper.GetPropertyByName(assembly, field.Name, "HasNext");
bool nextValue = (bool)hasNext.GetValue(repeat);
SbeMessage _Original = SbeLoader.LoadMessageByName(MessageName);
SbeField _OriginalField = _Original.Fields.Find(x => x.Name == field.Name).Clone();
field.Fields.Clear();
MethodInfo next = ReflectionHelper.GetNestedMethodByName(assembly, MessageName, field.Name + "Group", "next");
int size = 0;
while (nextValue)
{
size++;
next.Invoke(repeat, null);
foreach (SbeField child in _OriginalField.Fields)
{
if (!child.Presence.Contains("constant"))
{
if (SbeLoader._Enums.Find(x => x.Name == child.Type) != null)
{
Type _enumType = ReflectionHelper.GetType(assembly, child.Type);
if (_enumType.IsEnum)
{
SbeEnum _enum = SbeLoader._Enums.Find(x => x.Name == child.Type);
PropertyInfo pi = ReflectionHelper.GetPropertyByName(assembly, field.Name + "Group", child.Name);
child.ValueRef = Convert.ChangeType(pi.GetValue(repeat), pi.PropertyType).ToString();
SbeEnumValidValue valid = _enum.ValidValues.Find(x => x.Name == child.ValueRef);
if (valid != null)
{
child.Value = valid.Value;
}
}
}
else
{
PropertyInfo pi = ReflectionHelper.GetNestedPropertyByName(assembly, MessageName, field.Name + "Group", child.Name);
child.Value = pi.GetValue(repeat).ToString();
}
}
field.Fields.Add(child.Clone());
}
nextValue = (bool)hasNext.GetValue(repeat);
}
field.Value = size.ToString();
#endregion
}
else
{
PropertyInfo pi = ReflectionHelper.GetPropertyByName(assembly, MessageName, field.Type);
if (pi != null)
{
object parent = pi.GetValue(MessageBody);
foreach (SbeField child in field.Fields)
{
if (child.Presence.Contains("constant"))
{
continue;
}
PropertyInfo pi2 = ReflectionHelper.GetPropertyByName(assembly, field.Type, child.Name);
child.Value = pi2.GetValue(parent).ToString();
}
}
else
{
// length = car.GetManufacturer(buffer, 0, buffer.Length);
//sb.Append("\ncar.manufacturer=").Append(Encoding.GetEncoding(Car.ManufacturerCharacterEncoding).GetString(buffer, 0, length));
// length = car.GetModel(buffer, 0, buffer.Length);
//sb.Append("\ncar.model=").Append(Encoding.GetEncoding(Car.ModelCharacterEncoding).GetString(buffer, 0, length));
FieldInfo fi = ReflectionHelper.GetFieldByName(assembly, MessageName, field.Name + "CharacterEncoding");
var buffer = new byte[128];
MethodInfo mi = ReflectionHelper.GetMethodByName(assembly, MessageName, "Get" + field.Name, "byte[]");
int len = (int)(mi.Invoke(MessageBody, new object[] { buffer, 0, buffer.Length }));
field.Value = Encoding.GetEncoding(fi.GetValue(MessageBody).ToString()).GetString(buffer, 0, len);
}
}
#endregion
}
return(field);
}
public static void SetField(Assembly assembly, SbeField field, String MessageName, object MessageBody)
{
if (SbeLoader._Enums.Find(x => x.Name == field.Type) != null)
{
#region Enumeration
SetEnumerationField(assembly, field, MessageBody, MessageName);
#endregion
}
else if (SbeLoader._SimpleTypes.Find(x => x.Name == field.Type) != null)
{
#region Simple Type
if (field.Presence.Contains("constant") || String.IsNullOrEmpty(field.Value))
{
return;
}
//SimpleType
SbeType simple = SbeLoader._SimpleTypes.Find(x => x.Name == field.Type);
if (simple.PrimitiveType.ToLower().Equals("char"))
{
FieldInfo fi = ReflectionHelper.GetFieldByName(assembly, MessageName, field.Name + "CharacterEncoding");
byte[] fieldByte = System.Text.Encoding.GetEncoding(fi.GetValue(MessageBody).ToString()).GetBytes(field.Value);
MethodInfo mi = ReflectionHelper.GetMethodByName(assembly, MessageName, "Set" + field.Name, "byte[]");
mi.Invoke(MessageBody, new object[] { fieldByte, 0 });
}
else
{
PropertyInfo pi = ReflectionHelper.GetPropertyByName(assembly, MessageName, field.Name);
pi.SetValue(MessageBody, Convert.ChangeType(field.Value, pi.PropertyType));
}
#endregion
}
else if (SbeLoader._CompositeTypes.Find(x => x.Name == field.Type) != null)
{
#region Composite
if (field.Type.ToLower().Equals("groupsizeencoding"))
{
#region groupsizeencoding
//var sides = cross.NoSidesCount(2);
//sides.Next();
//sides.Side = Side.BUY;
//sides.Account = 111;
//sides.ClOrdID = 12345;
//sides.Next();
//sides.Side = Side.SELL;
//sides.Account = 222;
//sides.ClOrdID = 67890;
MethodInfo mi = ReflectionHelper.GetMethodByName(assembly, MessageName, field.Name + "Count");
var repeatGroup = mi.Invoke(MessageBody, new object[] { int.Parse(field.Value) });
MethodInfo next = ReflectionHelper.GetNestedMethodByName(assembly, MessageName, field.Name + "Group", "next");
SbeMessage _Original = SbeLoader.LoadMessageByName(MessageName);
SbeField _OriginalField = _Original.Fields.Find(x => x.Name == field.Name).Clone();
foreach (SbeField child in field.Fields)
{
if (child.Name == _OriginalField.Fields[0].Name)
{
next.Invoke(repeatGroup, null);
}
if (!String.IsNullOrEmpty(child.Value))
{
if (SbeLoader._Enums.Find(x => x.Name == child.Type) != null)
{
if (child.Presence.Contains("constant") || String.IsNullOrEmpty(child.Value))
{
continue;
}
Type _enumType = ReflectionHelper.GetType(assembly, child.Type);
if (_enumType.IsEnum)
{
SbeEnum _enum = SbeLoader._Enums.Find(x => x.Name == child.Type);
SbeEnumValidValue valid = _enum.ValidValues.Find(x => x.Value == child.Value);
PropertyInfo pi = ReflectionHelper.GetNestedPropertyByName(assembly, MessageName, field.Name + "Group", child.Name);
pi.SetValue(repeatGroup, Enum.Parse(_enumType, valid.Name));
}
}
else
{
PropertyInfo pi = ReflectionHelper.GetNestedPropertyByName(assembly, MessageName, field.Name + "Group", child.Name);
pi.SetValue(repeatGroup, Convert.ChangeType(child.Value, pi.PropertyType));
}
}
}
#endregion
}
else
{
PropertyInfo pi = ReflectionHelper.GetPropertyByName(assembly, MessageName, field.Type);
if (pi != null)
{
object parent = pi.GetValue(MessageBody);
foreach (SbeField child in field.Fields)
{
if (child.Presence.Contains("constant") || String.IsNullOrEmpty(child.Value))
{
continue;
}
PropertyInfo pi2 = ReflectionHelper.GetPropertyByName(assembly, field.Type, child.Name);
pi2.SetValue(parent, Convert.ChangeType(child.Value, pi2.PropertyType));
}
}
else
{
// Manufacturer = Encoding.GetEncoding(Car.ManufacturerCharacterEncoding).GetBytes("Honda");
// car.SetManufacturer(Manufacturer, srcOffset, Manufacturer.Length);
FieldInfo fi = ReflectionHelper.GetFieldByName(assembly, MessageName, field.Name + "CharacterEncoding");
byte[] fieldByte = System.Text.Encoding.GetEncoding(fi.GetValue(MessageBody).ToString())
.GetBytes(field.Value);
MethodInfo mi = ReflectionHelper.GetMethodByName(assembly, MessageName, "Set" + field.Name, "byte[]");
mi.Invoke(MessageBody, new object[] { fieldByte, 0, fieldByte.Length });
//mi.Invoke(MessageBody, new object[] { fieldByte, 0 });
}
}
#endregion
}
}
private void tree_CellEditFinishing(object sender, BrightIdeasSoftware.CellEditEventArgs e)
{
if (e.Cancel)
{
return;
}
SbeField field = (SbeField)e.RowObject;
if (e.Control is ComboBox)
{
if (e.Column.Text == "PrimitiveType")
{
field.PrimitiveType = e.Control.Text.Trim();
switch (field.PrimitiveType)
{
case "uint8":
case "int8":
field.Length = 1;
break;
case "uint16":
case "int16":
field.Length = 2;
break;
case "uint32":
case "int32":
field.Length = 4;
break;
case "uint64":
case "int64":
field.Length = 8;
break;
case "char":
field.Length = 10;
break;
}
}
else if (e.Column.Text == "Value")
{
if (e.Control.Text.Contains("|"))
{
field.Value = e.Control.Text.Split('|')[0].Trim();
}
else
{
field.Value = e.Control.Text.Trim();
}
}
}
else if (e.Control is TextBox)
{
if (e.Column.Text == "Value")
{
field.Value = e.Control.Text.Trim();
}
else if (e.Column.Text == "Length")
{
field.Length = int.Parse(e.Control.Text.Trim());
}
}
if (field.Type.ToLower().Equals("groupsizeencoding"))
{
try
{
int repeating = int.Parse(field.Value);
int repeatingGroupAtual = field.Fields.FindAll(x => x.Name == field.Fields[0].Name).Count;
SbeMessage _Original = null;
if (checkBox1.Checked)
{
_Original = SbeLoader.LoadMessageByName(_Message[1].Name);
}
else
{
_Original = SbeLoader.LoadMessageByName(_Message[0].Name);
}
SbeField _OriginalField = _Original.Fields.Find(x => x.Name == field.Name).Clone();
if (repeating > repeatingGroupAtual)
{
while (repeating > repeatingGroupAtual)
{
SbeField _FieldOriginal = _OriginalField.Clone();
field.Fields.AddRange(_FieldOriginal.Fields);
repeatingGroupAtual = field.Fields.FindAll(x => x.Name == field.Fields[0].Name).Count;
}
}
else if (repeating < repeatingGroupAtual)
{
while (repeating < repeatingGroupAtual)
{
foreach (SbeField _ChildField in _OriginalField.Fields)
{
SbeField toRemove = field.Fields.FindLast(x => x.Name == _ChildField.Name);
field.Fields.Remove(toRemove);
}
repeatingGroupAtual = field.Fields.FindAll(x => x.Name == field.Fields[0].Name).Count;
}
}
tree.Roots = _Message;
tree.ExpandAll();
}
catch
{
}
}
tree.RefreshItem(e.ListViewItem);
e.Cancel = true;
}
public byte[] EncodeSBEMessage(SbeMessage Message)
{
if (_Assembly == null)
{
throw new Exception("To use SBE Engine, please init SbeReflectionWrapper passing the sbe file dll as parameter");
}
var byteBuffer = new byte[4096];
var directBuffer = new DirectBuffer(byteBuffer);
int bufferOffset = 0;
Type MessageHeaderType = ReflectionHelper.GetType(_Assembly, _Header);
var MessageHeaderObj = ReflectionHelper.GetObjectByType(_Assembly, _Header);
Type MessageBodyType = ReflectionHelper.GetType(_Assembly, Message.Name);
var MessageBodyObj = ReflectionHelper.GetObjectByType(_Assembly, Message.Name);
FieldInfo schemaVersion = ReflectionHelper.GetFieldByName(_Assembly, Message.Name, "SchemaVersion");
//WRAP
MessageHeaderType.InvokeMember("Wrap", BindingFlags.InvokeMethod | BindingFlags.Instance | BindingFlags.Public,
null, MessageHeaderObj, new object[] { directBuffer, bufferOffset, schemaVersion.GetValue(MessageBodyObj) });
#region SET MESSAGE HEADER FIELDS
//BLOCK LENGTH
PropertyInfo blockLengthHeader = ReflectionHelper.GetPropertyByName(_Assembly, _Header, "BlockLength");
FieldInfo blockLengthBody = ReflectionHelper.GetFieldByName(_Assembly, Message.Name, "BlockLength");
blockLengthHeader.SetValue(MessageHeaderObj, blockLengthBody.GetValue(MessageBodyObj));
//SCHEMAID
PropertyInfo schemaIDHeader = ReflectionHelper.GetPropertyByName(_Assembly, _Header, "SchemaId");
FieldInfo schemaIDBody = ReflectionHelper.GetFieldByName(_Assembly, Message.Name, "SchemaId");
schemaIDHeader.SetValue(MessageHeaderObj, schemaIDBody.GetValue(MessageBodyObj));
//TEMPLATEID
PropertyInfo templateIdHeader = ReflectionHelper.GetPropertyByName(_Assembly, _Header, "TemplateId");
templateIdHeader.SetValue(MessageHeaderObj, Convert.ChangeType(Message.Id, templateIdHeader.PropertyType));
//VERSION
PropertyInfo versionHeader = ReflectionHelper.GetPropertyByName(_Assembly, _Header, "Version");
FieldInfo schemaVersionBody = ReflectionHelper.GetFieldByName(_Assembly, Message.Name, "SchemaVersion");
versionHeader.SetValue(MessageHeaderObj, schemaVersionBody.GetValue(MessageBodyObj));
#endregion
FieldInfo size = ReflectionHelper.GetFieldByName(_Assembly, _Header, "Size");
bufferOffset += int.Parse(size.GetValue(MessageHeaderObj).ToString());
MessageBodyType.InvokeMember("WrapForEncode", BindingFlags.InvokeMethod | BindingFlags.Instance | BindingFlags.Public,
null, MessageBodyObj, new object[] { directBuffer, bufferOffset });
foreach (SbeField field in Message.Fields)
{
ReflectionHelper.SetField(_Assembly, field, Message.Name, MessageBodyObj);
}
PropertyInfo sizeBody = ReflectionHelper.GetPropertyByName(_Assembly, Message.Name, "Size");
int BodyLength = int.Parse(sizeBody.GetValue(MessageBodyObj).ToString());
var tempBuffer = new byte[BodyLength + 8];
directBuffer.GetBytes(0, tempBuffer, 0, BodyLength + 8);
return(tempBuffer);
}
public String DecodeSBEMessage(byte[] MessageBytes)
{
if (_Assembly == null)
{
throw new Exception("To use SBE Engine, please init SbeReflectionWrapper passing the sbe file dll as parameter");
}
StringBuilder sb = new StringBuilder();
var directBuffer = new DirectBuffer(MessageBytes);
int bufferOffset = 0;
const short SchemaVersion = 0;
Type MessageHeaderType = ReflectionHelper.GetType(_Assembly, _Header);
var MessageHeaderObj = ReflectionHelper.GetObjectByType(_Assembly, _Header);
//WRAP
MessageHeaderType.InvokeMember("Wrap", BindingFlags.InvokeMethod | BindingFlags.Instance | BindingFlags.Public,
null, MessageHeaderObj, new object[] { directBuffer, bufferOffset, SchemaVersion });
PropertyInfo pi = ReflectionHelper.GetPropertyByName(_Assembly, _Header, "TemplateId");
string templateId = pi.GetValue(MessageHeaderObj).ToString().Trim();
Type MessageBodyType = ReflectionHelper.GetMessageTypeByTemplateId(_Assembly, templateId);
if (MessageBodyType == null)
{
throw new Exception(String.Format("TemplateID = {0} not found in the binary!", templateId));
}
SbeMessage Message = SbeLoader.LoadMessageById(templateId);
if (Message == null)
{
throw new Exception(String.Format("TemplateID = {0} not found in the protocol!", templateId));
}
PropertyInfo blockLength = ReflectionHelper.GetPropertyByName(_Assembly, _Header, "blockLength");
PropertyInfo schemaId = ReflectionHelper.GetPropertyByName(_Assembly, _Header, "schemaId");
PropertyInfo version = ReflectionHelper.GetPropertyByName(_Assembly, _Header, "version");
sb.AppendLine(CrackHelper.CreateLine("Header", "BlockLength", blockLength.GetValue(MessageHeaderObj).ToString().Trim()));
sb.AppendLine(CrackHelper.CreateLine("Header", "TemplateID", String.Format("{0} ({1})", templateId, Message.Name)));
sb.AppendLine(CrackHelper.CreateLine("Header", "SchemaId", schemaId.GetValue(MessageHeaderObj).ToString().Trim()));
sb.AppendLine(CrackHelper.CreateLine("Header", "Version", version.GetValue(MessageHeaderObj).ToString().Trim()));
var MessageBodyObj = ReflectionHelper.GetObjectByType(_Assembly, MessageBodyType.FullName);
FieldInfo size = ReflectionHelper.GetFieldByName(_Assembly, _Header, "Size");
bufferOffset += int.Parse(size.GetValue(MessageHeaderObj).ToString());
FieldInfo actingBlockLength = ReflectionHelper.GetFieldByName(_Assembly, MessageBodyType.Name, "BlockLength");
FieldInfo actingVersion = ReflectionHelper.GetFieldByName(_Assembly, MessageBodyType.Name, "Version");
MessageBodyType.InvokeMember("WrapForDecode", BindingFlags.InvokeMethod | BindingFlags.Instance | BindingFlags.Public,
null, MessageBodyObj, new object[] {
directBuffer,
bufferOffset,
int.Parse(actingBlockLength.GetValue(MessageHeaderObj).ToString()),
int.Parse(actingVersion.GetValue(MessageHeaderObj).ToString())
});
Message.FillFields(_Assembly, MessageBodyObj);
sb.Append(Message.Crack());
return(sb.ToString());
}
