/// <summary> /// Completes an asynchronous operation initiated by <see cref="BeginRequest(Message,AsyncCallback,object)" /> /// or <see cref="BeginRequest(Message,TimeSpan,AsyncCallback,object)" />. /// </summary> /// <param name="result">The <see cref="IAsyncResult" /> instance returned by <b>BeginRequest()</b>.</param> /// <returns>The correlated response message.</returns> public Message EndRequest(IAsyncResult result) { try { WcfEnvelopeMsg replyMsg; replyMsg = (WcfEnvelopeMsg)ChannelHost.Router.EndQuery(result); if (!base.CanAcceptMessages) { // This is a bit of a hack to simulate aborting pending // requests when the channel is closed. throw ServiceModelHelper.CreateObjectDisposedException(this); } // Decode the reply using (BlockStream bs = new BlockStream((Block)replyMsg.Payload)) return(encoder.ReadMessage(bs, ServiceModelHelper.MaxXmlHeaderSize)); } catch (Exception e) { throw ServiceModelHelper.GetCommunicationException(e); } }
/// <summary> /// constructor (stream) /// </summary> public GlobalCacheReader(Stream stream) { var blockStream = new BlockStream(new Zstandard(), stream, CompressionMode.Decompress); _reader = new ExtendedBinaryReader(blockStream, Encoding.UTF8); FileHeader = GetHeader(blockStream); }
public TranscriptCacheReader(Stream stream) { Header = CacheHeader.Read(stream); var blockStream = new BlockStream(new Zstandard(), stream, CompressionMode.Decompress); _reader = new BufferedBinaryReader(blockStream); }
public static NgaReader Read(Stream stream) { (IDataSourceVersion version, string jsonKey, bool isArray) = ReadHeader(stream); Dictionary <string, List <string> > geneSymbolToJsonStrings; using (var blockStream = new BlockStream(new Zstandard(), stream, CompressionMode.Decompress)) using (var reader = new ExtendedBinaryReader(blockStream)) { int geneCount = reader.ReadOptInt32(); geneSymbolToJsonStrings = new Dictionary <string, List <string> >(geneCount); for (var i = 0; i < geneCount; i++) { string geneSymbol = reader.ReadAsciiString(); int numEntries = reader.ReadOptInt32(); var entries = new List <string>(numEntries); for (var j = 0; j < numEntries; j++) { entries.Add(reader.ReadString()); } geneSymbolToJsonStrings[geneSymbol] = entries; } } return(new NgaReader(version, jsonKey, isArray, geneSymbolToJsonStrings)); }
public void T01_SimpleWriteRead() { BlockStream blocks = new BlockStream(); blocks.CreateMemoryStream(); Guid id = Guid.NewGuid(); Hashtable tags0 = new Hashtable(); tags0["Name"] = "Test Write"; tags0["Description"] = "Simple Write/Read Test."; byte[] bytes0 = new byte[256]; for (int ndx = 0; ndx < 256; ndx++) { bytes0[ndx] = (byte)ndx; } blocks.WriteBlock(id, tags0, bytes0); Hashtable tags1 = null; byte[] bytes1 = null; blocks.ReadBlock(id, ref tags1, ref bytes1); //Assert.IsTrue( DataManagement.AreEqual( tags0, tags1 ) ); Assert.IsTrue(DataManagement.AreEqual(bytes0, bytes1)); return; }
unsafe void SolveSingleJoint(JointData *jointData, int numIterations, float timestep, ref MotionVelocity velocityA, ref MotionVelocity velocityB, ref MotionData motionA, ref MotionData motionB, out BlockStream jacobiansOut) { Solver.StepInput stepInput = new Solver.StepInput { IsLastIteration = false, InvNumSolverIterations = 1.0f / numIterations, Timestep = timestep, InvTimestep = timestep > 0.0f ? 1.0f / timestep : 0.0f }; // Build jacobians jacobiansOut = new BlockStream(1, 0); { BlockStream.Writer jacobianWriter = jacobiansOut; jacobianWriter.BeginForEachIndex(0); Solver.BuildJointJacobian(jointData, new BodyIndexPair(), velocityA, velocityB, motionA, motionB, timestep, numIterations, ref jacobianWriter); jacobianWriter.EndForEachIndex(); } BlockStream.Writer eventWriter = new BlockStream.Writer(); // no events expected // Solve the joint for (int iIteration = 0; iIteration < numIterations; iIteration++) { stepInput.IsLastIteration = (iIteration == numIterations - 1); BlockStream.Reader jacobianReader = jacobiansOut; JacobianIterator jacIterator = new JacobianIterator(jacobianReader, 0); while (jacIterator.HasJacobiansLeft()) { ref JacobianHeader header = ref jacIterator.ReadJacobianHeader(); header.Solve(ref velocityA, ref velocityB, stepInput, ref eventWriter, ref eventWriter); } }
public TranscriptCacheReader(Stream stream) { var blockStream = new BlockStream(new Zstandard(), stream, CompressionMode.Decompress); _reader = new ExtendedBinaryReader(blockStream, Encoding.UTF8); Header = blockStream.ReadHeader(CacheHeader.Read, TranscriptCacheCustomHeader.Read) as CacheHeader; }
public unsafe void Execute(uint stage, SharpMedia.Database.Physical.Journalling.IService service) { Debug.Assert(stage == 0); // 1) We first write object to stream. BlockStream stream = service.AllocationContext.CreateBlockStream((ulong)objectData.LongLength); stream.Write(objectData); // 2) We may need to delete object from B+ stream. Block block = service.Read(BlockType.TypedStreamHeader, typedStreamHeader); fixed(byte *p = block.Data) { TypedStreamHeader *header = (TypedStreamHeader *)p; // We may need to delete link. if (header->ObjectsAddress != 0) { BlockStream objToDelete = BlockStream.FromBase(header->ObjectsAddress, service); objToDelete.Deallocate(); } // 3) We must relink it to out block. header->ObjectsAddress = stream.BaseAddress; header->ObjectSize = (ulong)objectData.LongLength; } service.Write(BlockType.TypedStreamHeader, typedStreamHeader, block); }
/// <summary> /// Internal prepare /// </summary> /// <param name="readService"></param> /// <param name="data"></param> /// <param name="subOps"></param> unsafe void PrepareInternal(IReadService readService, List <DeleteChild> subOps) { // We inspect children. ulong childrenTS; Block block = readService.Read(BlockType.NodeHeaderBlock, commonAddress); fixed(byte *p = block.Data) { NodeCommonHeader *header = (NodeCommonHeader *)p; childrenTS = header->ChildrenBTree; } // We check children count. BPlusTree tree = new BPlusTree(childrenTS); List <ObjectInfo> objects = tree.ListAll(readService); // We update stage index/count. for (int j = 0; j < objects.Count; j++) { BlockStream childTagStream = BlockStream.FromBase(objects[j].Address, readService); ChildTag childTag = Common.DeserializeFromArray(childTagStream.Read(objects[j].Size)) as ChildTag; foreach (KeyValuePair <string, ulong> child in childTag.Children) { DeleteChild subOp = new DeleteChild(child.Value, childrenTS, child.Key); subOps.Add(subOp); } } subOps.Add(this); }
static void ReadBlocks() { var zmq = new SubscriberSocket(Config.BitcoinRawBlocks); zmq.Subscribe("rawblock"); //zmq.Subscribe("rawtx"); //zmq.SubscribeToAnyTopic(); Console.WriteLine("Waiting for blocks.."); while (IsRunning) { var msg = zmq.ReceiveMultipartMessage(); var tag = msg[0].ConvertToString(); var msg_data = msg[1].Buffer; if (tag == "rawtx") { var tx = Transaction.Load(msg_data, Network.Main); Console.WriteLine($"Got new tx! {tx}"); } else if (tag == "rawblock") { var bp = Block.Load(msg_data, Consensus.Main); BlockStream.Post(bp); } } }
public void BlockStream_ToByteArray() { BlockStream s = new BlockStream(); s.Write(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }, 0, 10); CollectionAssert.AreEqual(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }, s.ToArray()); }
private static CacheHeader GetHeader(BlockStream blockStream, out DemoCustomHeader customHeader) { var header = (CacheHeader)blockStream.ReadHeader(CacheHeader.Read, DemoCustomHeader.Read); customHeader = header.CustomHeader as DemoCustomHeader; return(header); }
public PredictionCacheWriter(BlockStream blockStream, CacheHeader header, bool leaveOpen = false) { _blockStream = blockStream; _writer = new BinaryWriter(blockStream); _header = header; _leaveOpen = leaveOpen; }
/// <summary> /// Serializes the request/response line and headers into a binary /// form suitiable for network transmission. /// </summary> /// <param name="blockSize">Size of the underlying blocks.</param> /// <returns>The request as a block array.</returns> internal BlockArray Serialize(int blockSize) { var bs = new BlockStream(0, blockSize); var writer = new StreamWriter(bs); if (isRequest) { writer.Write("{0} {1} HTTP/{2}.{3}\r\n", method, rawUri, version.Major, version.Major); } else { writer.Write("HTTP/{0}.{1} {2} {3}\r\n", version.Major, version.Major, (int)status, reason); } foreach (HttpHeader header in headers.Values) { writer.Write("{0}: {1}\r\n", header.Name, header.Value); } writer.Write("\r\n"); writer.Flush(); return(bs.ToBlocks(true)); }
public static FileDescriptor Create(EndianReader reader, BlockStream block) { FileDescriptor file = new FileDescriptor(); file.Name = reader.ReadString(0x28); byte namelen = reader.ReadByte(); file.Flags = (byte)(namelen & 0xC0); file.BlockSize = ReadUInt24LE(reader); if (ReadUInt24LE(reader) != file.BlockSize) { throw new FormatException(); } file.Block = ReadUInt24LE(reader); file.Parent = reader.ReadUInt16(); file.Size = reader.ReadUInt32(); file.UpdateTime = reader.ReadUInt32(); file.AccessTime = reader.ReadUInt32(); if ((file.Flags & 0x80) == 0) { file.Data = new Substream(block, block.GetBlockOffset(file.Block), file.Size); } return(file); }
public void EndOfFile() { using (var ms = new MemoryStream()) { var writeBuffer = GetRandomBytes(100); var readBuffer = new byte[60]; using (var blockStream = new BlockStream(Zstd, ms, CompressionMode.Compress, true)) { blockStream.Write(writeBuffer, 0, writeBuffer.Length); } ms.Position = 0; using (var blockStream = new BlockStream(Zstd, ms, CompressionMode.Decompress)) { int numBytesRead = blockStream.Read(readBuffer, 0, readBuffer.Length); Assert.Equal(readBuffer.Length, numBytesRead); numBytesRead = blockStream.Read(readBuffer, 0, readBuffer.Length); Assert.Equal(writeBuffer.Length - readBuffer.Length, numBytesRead); numBytesRead = blockStream.Read(readBuffer, 0, readBuffer.Length); Assert.Equal(0, numBytesRead); } } }
public void Execute(uint stage, SharpMedia.Database.Physical.Journalling.IService service) { Debug.Assert(stage == 0); // 1) We first write to allocated block stream. BlockStream stream = service.AllocationContext.CreateBlockStream((ulong)objectData.LongLength); stream.Write(objectData); // 2) We may need to delete object at index. ObjectInfo data = tree.Find(service, index); if (data != null) { // Deallocate link. BlockStream stream2 = BlockStream.FromBase(data.Address, service); stream2.Deallocate(); // We replace the entry (cheaper than delete and rewrite). tree.Replace(service, new ObjectInfo(index, (ulong)objectData.LongLength, stream.BaseAddress)); } else { // 3) We execute insert operation. tree.Add(service, new ObjectInfo(index, (ulong)objectData.LongLength, stream.BaseAddress)); } }
private static void WriteBlockStream(ICompressionAlgorithm compressionAlgorithm, CacheHeader header, DemoCustomHeader customHeader, MemoryStream ms, string s) { using (var blockStream = new BlockStream(compressionAlgorithm, ms, CompressionMode.Compress, true)) using (var writer = new ExtendedBinaryWriter(blockStream)) { CheckReadException(blockStream); blockStream.WriteHeader(header.Write); var bp = new BlockStream.BlockPosition(); // detect that we have written a block blockStream.GetBlockPosition(bp); writer.WriteOptAscii(s); blockStream.GetBlockPosition(bp); // here we write a test string that won't invoke a new block blockStream.GetBlockPosition(customHeader.DemoPosition); writer.WriteOptAscii(SmallString); blockStream.GetBlockPosition(bp); Assert.Equal(customHeader.DemoPosition.FileOffset, blockStream.Position); blockStream.Flush(); // this will be flushed during dispose writer.WriteOptAscii(FinalString); } }
private void _httpServer_UnhandledRequestReceived(object sender, UnhandledRequestReceivedEventArgs args) { HttpRequestMessage requestMsg = args.Context.Request; if (requestMsg.Content is BlockStreamContent streamContent) { BlockStream stream = streamContent.Stream; FileStream fs = null; try { fs = File.Open("d:\\test\\test.exe", FileMode.Create, FileAccess.Write); stream.CopyTo(fs); } finally { if (fs != null) { fs.Close(); } } HttpResponseMessage responseMsg = ResponseMsgHelper.CreateSimpleRepMsg(); args.Context.Response = responseMsg; } else if (requestMsg.Content is ByteArrayContent byteContent) { } }
public void BlockOffset() { BlockStream s; BlockArray ba; s = new BlockStream(0, 10, 5); for (int i = 0; i < 20; i++) { s.WriteByte((byte)i); } ba = s.ToBlocks(false); Assert.Equal(4, ba.Count); for (int i = 0; i < ba.Count; i++) { Block b = ba.GetBlock(i); Assert.Equal(5, b.Length); Assert.Equal(5, b.Offset); for (int j = 0; j < 5; j++) { Assert.Equal(i * 5 + j, (int)b.Buffer[b.Offset + j]); } } }
public void ReadBlocks() { BlockStream s = new BlockStream(new Block(new byte[] { 0, 1, 2, 3, 4 }), new Block(new byte[] { 5, 6, 7, 8, 9 })); BlockArray ba; Assert.Equal(0, s.Position); ba = s.ReadBlocks(10); Assert.Equal(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }, ba.ToByteArray()); Assert.Equal(10, ba.Size); Assert.Equal(10, s.Position); s.Position = 5; ba = s.ReadBlocks(10); Assert.Equal(new byte[] { 5, 6, 7, 8, 9 }, ba.ToByteArray()); Assert.Equal(5, ba.Size); Assert.Equal(10, s.Position); s.Position = 3; ba = s.ReadBlocks(5); Assert.Equal(new byte[] { 3, 4, 5, 6, 7 }, ba.ToByteArray()); Assert.Equal(8, s.Position); s.Position = 0; }
public void SetLength_NoModify() { BlockStream s; BlockArray ba; byte[] buf; int cb; ba = new BlockArray(new Block(new byte[] { 0, 1, 2, 3, 4 }), new Block(new byte[] { 5, 6, 7, 8, 9 })); s = new BlockStream(ba); Assert.Equal(10, s.Length); s.Position = 10; s.SetLength(5, false); Assert.Equal(5, s.Length); Assert.Equal(5, s.Position); Assert.Equal(2, ba.Count); s.Position = 0; buf = new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; cb = s.Read(buf, 0, 10); Assert.Equal(5, cb); Assert.Equal(new byte[] { 0, 1, 2, 3, 4, 0, 0, 0, 0, 0 }, buf); s.Position = 0; s.SetLength(10, false); buf = new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; cb = s.Read(buf, 0, 10); Assert.Equal(10, cb); Assert.Equal(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }, buf); }
public void ToByteArray() { BlockStream s = new BlockStream(); s.Write(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }, 0, 10); Assert.Equal(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }, s.ToArray()); }
public void ReadWriteByte() { BlockStream s; int cb; s = new BlockStream(); cb = 1024 * 1024; Assert.Equal(-1, s.ReadByte()); Assert.Equal(0, s.Length); Assert.Equal(0, s.Position); for (int i = 0; i < cb; i++) { s.WriteByte((byte)i); } s.Position = 0; for (int i = 0; i < cb; i++) { Assert.Equal((byte)i, s.ReadByte()); } Assert.Equal(cb, s.Length); Assert.Equal(cb, s.Position); Assert.Equal(-1, s.ReadByte()); Assert.Equal(cb, s.Length); Assert.Equal(cb, s.Position); }
public void SetLength_Modify() { BlockStream s; byte[] r = new byte[10]; byte[] w = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; byte[] c = new byte[10]; s = new BlockStream(); s.SetLength(100000, true); Assert.Equal(100000, s.Length); Assert.Equal(0, s.Position); s.Position = 50000; s.Write(w, 0, 10); Assert.Equal(50010, s.Position); s.SetLength(50005, true); Assert.Equal(50005, s.Length); Assert.Equal(50005, s.Position); s.Position = 50000; Zero(r); Assert.Equal(5, s.Read(r, 0, 10)); Assert.Equal(new byte[] { 0, 1, 2, 3, 4, 0, 0, 0, 0, 0 }, r); s.SetLength(0, true); Assert.Equal(0, s.Length); Assert.Equal(0, s.Position); }
public TranscriptCacheWriter(Stream stream, CacheHeader header, bool leaveOpen = false) { _blockStream = new BlockStream(new Zstandard(), stream, CompressionMode.Compress); _writer = new ExtendedBinaryWriter(_blockStream, Encoding.UTF8, leaveOpen); _header = header; _leaveOpen = leaveOpen; }
public void ToArray([Values(1, 100, 200)] int count, [Values(1, 3, 10)] int batchSize) { var stream = new BlockStream(count, 0x11843789); var fillInts = new WriteInts { Writer = stream }; fillInts.Schedule(count, batchSize).Complete(); var array = stream.ToNativeArray <int>(); int itemIndex = 0; for (int i = 0; i != count; ++i) { for (int j = 0; j < i; ++j) { Assert.AreEqual(j, array[itemIndex]); itemIndex++; } } array.Dispose(); stream.Dispose(); }
public void Execute(uint stage, SharpMedia.Database.Physical.Journalling.IService service) { // 1) We read previous object placement and change it. ObjectInfo info = childrenTree.Find(service, (uint)prevName.GetHashCode()); BlockStream stream = BlockStream.FromBase(info.Address, service); ChildTag childTag = Common.DeserializeFromArray(stream.Read(info.Size)) as ChildTag; childTag.Remove(prevName); // Remove it if empty. if (childTag.IsEmpty) { childrenTree.Remove(service, (uint)prevName.GetHashCode(), 1, false); } else { // Update the entry (now without this child). byte[] childTagData = Common.SerializeToArray(childTag); stream = service.AllocationContext.CreateBlockStream((ulong)childTagData.LongLength); stream.Write(childTagData); childrenTree.Replace(service, new ObjectInfo((uint)prevName.GetHashCode(), (ulong)childTagData.LongLength, stream.BaseAddress)); } // 3) We create new and insert it into tree. ObjectInfo info2 = childrenTree.Find(service, (uint)newName.GetHashCode()); if (info2 == null) { // We create new tag. childTag = new ChildTag(); childTag.Add(newName, info.Address); byte[] childTagData = Common.SerializeToArray(childTag); stream = service.AllocationContext.CreateBlockStream((ulong)childTagData.LongLength); stream.Write(childTagData); // And we add child. childrenTree.Add(service, new ObjectInfo((uint)newName.GetHashCode(), (ulong)childTagData.LongLength, stream.BaseAddress)); } else { // We append it and release previous tag. stream = BlockStream.FromBase(info2.Address, service); childTag = Common.DeserializeFromArray(stream.Read(info2.Size)) as ChildTag; stream.Deallocate(); // We modify and rewrite it. childTag.Add(newName, info.Address); byte[] childTagData = Common.SerializeToArray(childTag); stream = service.AllocationContext.CreateBlockStream((ulong)childTagData.LongLength); stream.Write(childTagData); // We insert into children tree. childrenTree.Replace(service, new ObjectInfo((uint)newName.GetHashCode(), (ulong)childTagData.LongLength, info.Address)); } }
private static FileHeader GetHeader(BlockStream blockStream, out DemoCustomHeader customHeader) { var headerType = FileHeader.GetHeader(0, GenomeAssembly.Unknown, new DemoCustomHeader(new BlockStream.BlockPosition())); var header = (FileHeader)blockStream.ReadHeader(headerType); customHeader = header.Custom as DemoCustomHeader; return(header); }
public void Write(Stream stream) { using (var blockStream = new BlockStream(new Zstandard(), stream, CompressionMode.Compress)) using (var writer = new PredictionCacheWriter(blockStream, _header)) { writer.Write(_header.LookupTable, _predictionsPerRef); } }
public static void Main(string[] args) { var showHelp = false; string classFilter = null; var options = new OptionSet() { { "c|class=", "only unpack exports that are instances of specified class, ie Core.GFxUI.GFxMovieInfo", v => classFilter = v }, { "h|help", "show this message and exit", v => showHelp = v != null }, }; List<string> extras; try { extras = options.Parse(args); } catch (OptionException e) { Console.Write("{0}: ", GetExecutableName()); Console.WriteLine(e.Message); Console.WriteLine("Try `{0} --help' for more information.", GetExecutableName()); return; } if (extras.Count < 1 || extras.Count > 2 || showHelp == true) { Console.WriteLine("Usage: {0} [OPTIONS]+ -j input_pcc [output_pcc]", GetExecutableName()); Console.WriteLine(); Console.WriteLine("Options:"); options.WriteOptionDescriptions(Console.Out); return; } var inputPath = extras[0]; var outputPath = extras.Count >= 2 ? extras[1] : Path.ChangeExtension(inputPath, null); using (var input = File.OpenRead(inputPath)) { var magic = input.ReadValueU32(Endian.Little); if (magic != 0x9E2A83C1 && magic.Swap() != 0x9E2A83C1) { throw new FormatException("not a package"); } var endian = magic == 0x9E2A83C1 ? Endian.Little : Endian.Big; var encoding = endian == Endian.Little ? Encoding.Unicode : Encoding.BigEndianUnicode; var versionLo = input.ReadValueU16(endian); var versionHi = input.ReadValueU16(endian); if (versionLo != 684 && versionHi != 194) { throw new FormatException("unsupported version"); } input.Seek(4, SeekOrigin.Current); var folderNameLength = input.ReadValueS32(endian); var folderNameByteLength = folderNameLength >= 0 ? folderNameLength : (-folderNameLength * 2); input.Seek(folderNameByteLength, SeekOrigin.Current); /*var packageFlagsOffset = input.Position;*/ var packageFlags = input.ReadValueU32(endian); if ((packageFlags & 8) != 0) { input.Seek(4, SeekOrigin.Current); } var nameCount = input.ReadValueU32(endian); var namesOffset = input.ReadValueU32(endian); var exportCount = input.ReadValueU32(endian); var exportInfosOffset = input.ReadValueU32(endian); var importCount = input.ReadValueU32(endian); var importInfosOffset = input.ReadValueU32(endian); Stream data; if ((packageFlags & 0x02000000) == 0) { data = input; } else { input.Seek(36, SeekOrigin.Current); var generationsCount = input.ReadValueU32(endian); input.Seek(generationsCount * 12, SeekOrigin.Current); input.Seek(20, SeekOrigin.Current); var blockCount = input.ReadValueU32(endian); var blockStream = new BlockStream(input); for (int i = 0; i < blockCount; i++) { var uncompressedOffset = input.ReadValueU32(endian); var uncompressedSize = input.ReadValueU32(endian); var compressedOffset = input.ReadValueU32(endian); var compressedSize = input.ReadValueU32(endian); blockStream.AddBlock( uncompressedOffset, uncompressedSize, compressedOffset, compressedSize); } data = blockStream; } var names = new string[nameCount]; var exportInfos = new ExportInfo[exportCount]; for (uint i = 0; i < exportCount; i++) { exportInfos[i] = new ExportInfo(); } var importInfos = new ImportInfo[importCount]; for (uint i = 0; i < importCount; i++) { importInfos[i] = new ImportInfo(); } data.Seek(namesOffset, SeekOrigin.Begin); for (uint i = 0; i < nameCount; i++) { var nameLength = data.ReadValueS32(endian); if (nameLength >= 0) { names[i] = data.ReadString(nameLength, true, Encoding.UTF8); } else { names[i] = data.ReadString(-nameLength * 2, true, encoding); } } data.Seek(importInfosOffset, SeekOrigin.Begin); for (uint i = 0; i < importCount; i++) { var importInfo = importInfos[i]; var packageNameIndex = data.ReadValueS32(endian); importInfo.PackageName = names[packageNameIndex]; data.Seek(12, SeekOrigin.Current); var outerIndex = data.ReadValueS32(endian); importInfo.Outer = GetResource(exportInfos, importInfos, outerIndex); var objectNameIndex = data.ReadValueS32(endian); importInfo.ObjectName = names[objectNameIndex]; data.Seek(4, SeekOrigin.Current); } data.Seek(exportInfosOffset, SeekOrigin.Begin); for (uint i = 0; i < exportCount; i++) { var exportInfo = exportInfos[i]; exportInfo.PackageName = Path.GetFileNameWithoutExtension(inputPath); var classIndex = data.ReadValueS32(endian); exportInfo.Class = GetResource(exportInfos, importInfos, classIndex); data.Seek(4, SeekOrigin.Current); var outerIndex = data.ReadValueS32(endian); exportInfo.Outer = GetResource(exportInfos, importInfos, outerIndex); var objectNameIndex = data.ReadValueS32(endian); exportInfo.ObjectName = names[objectNameIndex]; data.Seek(16, SeekOrigin.Current); exportInfo.DataSize = data.ReadValueU32(endian); exportInfo.DataOffset = data.ReadValueU32(endian); data.Seek(4, SeekOrigin.Current); var count = data.ReadValueU32(endian); data.Seek(count * 4, SeekOrigin.Current); data.Seek(20, SeekOrigin.Current); } for (int i = 0; i < exportInfos.Length; i++) { var exportInfo = exportInfos[i]; if (classFilter != null) { if (exportInfo.Class == null) { continue; } if (exportInfo.Class.FullName.ToLowerInvariant() != classFilter) { continue; } } if (exportInfo.Class == null) { Console.WriteLine("{0}", exportInfo.FullName); } else { Console.WriteLine("({0}) {1}", exportInfo.Class.FullName, exportInfo.FullName); } var fullPath = exportInfo.FullPath; fullPath = fullPath.Replace(":", "_"); var exportPath = Path.Combine(outputPath, fullPath + " [export#" + i.ToString(CultureInfo.InvariantCulture) + "].bin"); if (File.Exists(exportPath) == true) { throw new InvalidOperationException(); } Directory.CreateDirectory(Path.GetDirectoryName(exportPath)); using (var output = File.Create(exportPath)) { data.Seek(exportInfo.DataOffset, SeekOrigin.Begin); output.WriteFromStream(data, exportInfo.DataSize); } } } }