public unsafe static byte[] GetStructureBytes(ValueType structure) { Type t = structure.GetType(); if (t.IsPrimitive || t.IsLayoutSequential) { return(ExtractOperation.ValueStructureToBytes(structure)); } byte[] b = null; var _structure = structure; if (structure is DateTime) { b = new byte[8]; _structure = ((DateTime)structure).ToBinary(); } else if (structure is Enum) { b = new byte[4]; _structure = Convert.ToInt32((Enum)structure); } else { b = new byte[Marshal.SizeOf(_structure)]; } fixed(byte *pb = b) Marshal.StructureToPtr(_structure, new IntPtr(pb), false); return(b); }
[Fact] public unsafe void Extractor_StructModel_Test() { StructModel[] structure = new StructModel[] { new StructModel(83948930), new StructModel(45453), new StructModel(5435332) }; structure[0].Alias = "FirstAlias"; structure[0].Name = "FirstName"; structure[1].Alias = "SecondAlia"; structure[1].Name = "SecondName"; structure[2].Alias = "ThirdAlias"; structure[2].Name = "ThirdName"; StructModels structures = new StructModels(structure); int size = Marshal.SizeOf(structure[0]); byte *pserial = ExtractOperation.ValueStructureToPointer(structure[0]); StructModel structure2 = new StructModel(); ValueType o = structure2; ExtractOperation.PointerToValueStructure(pserial, o, 0); structure2 = (StructModel)o; structure2.Alias = "FirstChange"; }
public unsafe static void StructureToPointer(object structure, IntPtr binary) { if (structure is ValueType) { Type t = structure.GetType(); if (t.IsPrimitive || t.IsLayoutSequential) { Marshal.StructureToPtr(structure, binary, false); return; } if (structure is DateTime) { structure = ((DateTime)structure).ToBinary(); Marshal.StructureToPtr(structure, binary, false); return; } if (t.IsLayoutSequential) { ExtractOperation.ValueStructureToPointer(structure, (byte *)binary, 0); return; } } Marshal.StructureToPtr(structure, binary, false); }
public unsafe static Byte[] GetBytes(this Object objvalue) { Type t = objvalue.GetType(); if (objvalue is ValueType) { if (t.IsPrimitive || t.IsLayoutSequential) { return(ExtractOperation.ValueStructureToBytes(objvalue)); } if (objvalue is DateTime) { return(((DateTime)objvalue).ToBinary().GetBytes()); } if (objvalue is Enum) { return(Convert.ToInt32(objvalue).GetBytes()); } return(objvalue.GetSequentialBytes()); } if (t.IsLayoutSequential) { return(objvalue.GetSequentialBytes()); } if (objvalue is IUnique) { return(((IUnique)objvalue).GetBytes()); } if (objvalue is String || objvalue is IFormattable) { return(objvalue.ToString().GetBytes()); } return(new byte[0]); }
public unsafe static object BytesToStructure(byte[] binary, object structure, long offset) { if (structure is ValueType) { return(ExtractOperation.BytesToValueStructure(binary, structure, 0)); } else { fixed(byte *b = &binary[offset]) return(PointerToStructure(new IntPtr(b), structure)); } }
public unsafe static byte[] GetStructureBytes(object structure) { byte[] b = null; object _structure = structure; if (_structure is string) { int l = ((string)_structure).Length; b = new byte[l]; fixed(char *c = (string)_structure) fixed(byte *pb = b) CopyBlock(pb, (byte *)c, l); } if (structure is ValueType) { Type t = structure.GetType(); if (t.IsPrimitive || t.IsLayoutSequential) { return(ExtractOperation.ValueStructureToBytes(structure)); } if (structure is DateTime) { b = new byte[8]; _structure = ((DateTime)_structure).ToBinary(); } else if (structure is Enum) { b = new byte[4]; structure = Convert.ToInt32((Enum)structure); } else { b = new byte[Marshal.SizeOf(_structure)]; } } else { b = new byte[Marshal.SizeOf(_structure)]; fixed(byte *pb = b) Marshal.StructureToPtr(_structure, new IntPtr(pb), false); return(b); }
public unsafe static byte *GetStructurePointer(object structure) { int size = 0; if (structure is ValueType) { Type t = structure.GetType(); if (t.IsPrimitive || t.IsLayoutSequential) { return(ExtractOperation.ValueStructureToPointer(structure)); } if (structure is DateTime) { size = 8; structure = ((DateTime)structure).ToBinary(); } else if (structure is ISerialNumber) { size = 24; } else if (structure is IUnique) { size = 8; } else if (structure is Enum) { size = 4; structure = Convert.ToInt32((Enum)structure); } else { size = Marshal.SizeOf(structure); } } else { size = Marshal.SizeOf(structure); } IntPtr p = Marshal.AllocHGlobal(Marshal.SizeOf(structure)); Marshal.StructureToPtr(structure, p, false); return((byte *)p); }
public unsafe static object PointerToStructure(IntPtr binary, object structure) { if (structure is ValueType) { Type t = structure.GetType(); if (t.IsPrimitive || t.IsLayoutSequential) { structure = ExtractOperation.PointerToValueStructure((byte *)binary, structure, 0); } else { structure = PointerToStructure(binary, structure.GetType(), 0); } } else { Marshal.PtrToStructure(binary, structure); } return(structure); }
public static unsafe void CopyBlock(byte *dest, byte *src, uint count) { ExtractOperation.CopyBlock(dest, 0, src, 0, count); }
public static unsafe void CopyBlock(byte *dest, ulong destOffset, byte *src, ulong srcOffset, ulong count) { ExtractOperation.CopyBlock(dest, destOffset, src, srcOffset, count); }
public static unsafe void CopyBlock(void *dest, void *src, ulong count) { ExtractOperation.CopyBlock((byte *)dest, 0, (byte *)src, 0, count); }
public static unsafe void Cpblk(IntPtr dest, IntPtr src, ulong destOffset, ulong count) { ExtractOperation.CopyBlock((byte *)(dest.ToPointer()), destOffset, (byte *)(src.ToPointer()), 0, count); }
public static unsafe void CopyBlock(void *dest, void *src, uint destOffset, uint count) { ExtractOperation.CopyBlock((byte *)dest, destOffset, (byte *)src, 0, count); }
public static unsafe void Cpblk(byte *dest, byte *src, uint destOffset, uint count) { ExtractOperation.CopyBlock(dest, destOffset, src, 0, count); }
public static unsafe void CopyBlock(IntPtr dest, long destOffset, IntPtr src, long srcOffset, long count) { ExtractOperation.CopyBlock((byte *)(dest.ToPointer()), (ulong)destOffset, (byte *)(src.ToPointer()), (ulong)srcOffset, (ulong)count); }
public static unsafe void CopyBlock(IntPtr dest, uint destOffset, IntPtr src, uint srcOffset, uint count) { ExtractOperation.CopyBlock((byte *)(dest.ToPointer()), destOffset, (byte *)(src.ToPointer()), srcOffset, count); }
public static unsafe void CopyBlock(void *dest, ulong destOffset, void *src, ulong srcOffset, ulong count) { ExtractOperation.CopyBlock((byte *)dest, destOffset, (byte *)src, srcOffset, count); }
public unsafe static ValueType PointerToStructure(IntPtr binary, ValueType structure) { return(ExtractOperation.PointerToValueStructure((byte *)binary, structure, 0)); }
public static unsafe void CopyBlock(byte *dest, byte *src, long count) { ExtractOperation.CopyBlock(dest, 0, src, 0, (ulong)count); }
public unsafe static ValueType BytesToStructure(byte[] binary, ValueType structure, long offset) { return(ExtractOperation.BytesToValueStructure(binary, structure, 0)); }
public static unsafe void CopyBlock(byte[] dest, uint destOffset, byte[] src, uint srcOffset, uint count) { ExtractOperation.CopyBlock(dest, destOffset, src, srcOffset, count); }
public static unsafe void CopyBlock(void *dest, void *src, long destOffset, long count) { ExtractOperation.CopyBlock((byte *)dest, (ulong)destOffset, (byte *)src, 0, (ulong)count); }
public static unsafe void CopyBlock(byte[] dest, byte[] src, ulong count) { ExtractOperation.CopyBlock(dest, 0, src, 0, count); }
public static unsafe void CopyBlock(byte[] dest, byte[] src, int destOffset, int count) { ExtractOperation.CopyBlock(dest, (uint)destOffset, src, 0, (uint)count); }
public static unsafe void CopyBlock(IntPtr dest, IntPtr src, int destOffset, int count) { ExtractOperation.CopyBlock((byte *)src.ToPointer(), (uint)destOffset, (byte *)dest.ToPointer(), 0, (uint)count); }
public static unsafe void CopyBlock(byte[] dest, long destOffset, byte[] src, long srcOffset, long count) { ExtractOperation.CopyBlock(dest, (ulong)destOffset, src, (ulong)srcOffset, (ulong)count); }