Разбор бинарного файла

        struct UNKNOWN_HEADER_MIDDLE
        {
            public uint u0;
            public ushort u1;
        }
 
        struct UNKNOWN_HEADER_END
        {
            public ushort u0;
            public ushort u1;
            public ushort u2;
            public ushort u3;
            public ushort u4;
        }
 
        class UnknownFileData
        {
            private string mName;
 
            public string Name
            {
                get { return mName; }
                set
                {
                    if ( value == null )
                        throw new ArgumentNullException();
 
                    if ( value.Length > 6 )
                        value = value.Substring( 0, 6 );
 
                    mName = value;
                }
            }
 
            public UNKNOWN_HEADER_MIDDLE Unknown0;
            public DateTime DateTime { get; set; }
            public UNKNOWN_HEADER_END Unknown1;
            public byte[] BinaryData { get; set; }
        }
 
        static class UnknownFileManager
        {
            const int DATA_OFFSET = 
                6 +  // ID length
                2 +  // Total chunk length
                6 +  // Name length
                6 +  // UNKNOWN_HEADER_MIDDLE
                10 + // DateTime (10 bytes)
                10;  // UNKNOWN_HEADER_END
 
            static readonly byte[] ValidHeader = new byte[] { 0x3, 0x0, 0x0, 0x0, 0x0, 0x0 };
 
            public static List<UnknownFileData> ReadFile ( string fileName )
            {
                var list = new List<UnknownFileData>();
 
                using ( var fileStream = File.Open( fileName, FileMode.Open, FileAccess.Read, FileShare.Read ) )
                {
                    var br         = new BinaryReader( fileStream, Encoding.Default );
                    var dataLength = 0;
 
                    while ( true )
                    {
                        if ( !CheckHeader( br.ReadBytes( 6 ) ) )
                            throw new InvalidDataException( "Invalid header!" );
                        if ( fileStream.Position >= fileStream.Length )
                            break; // EOF
 
                        var unknownData = new UnknownFileData();
                        dataLength = br.ReadUInt16() - DATA_OFFSET;
 
                        unknownData.Name = new string( br.ReadChars( 6 ) );
                        // .: UNKNOWN_HEADER_MIDDLE :.
                        unknownData.Unknown0.u0 = br.ReadUInt32();
                        unknownData.Unknown0.u1 = br.ReadUInt16();
                        // ---
                        unknownData.DateTime = new DateTime(
                                                    br.ReadUInt16(), // Year
                                                    br.ReadUInt16(), // Month
                                                    br.ReadUInt16(), // Day
                                                    br.ReadUInt16(), // Hour
                                                    br.ReadUInt16(), // Minute
                                                    0 /* Seconds, always zero */)
                                                    .AddYears( 2000 );
                        // .: UNKNOWN_HEADER_END :.
                        unknownData.Unknown1.u0 = br.ReadUInt16();
                        unknownData.Unknown1.u1 = br.ReadUInt16();
                        unknownData.Unknown1.u2 = br.ReadUInt16();
                        unknownData.Unknown1.u3 = br.ReadUInt16();
                        unknownData.Unknown1.u4 = br.ReadUInt16();
                        // ---
                        unknownData.BinaryData = br.ReadBytes( dataLength );
 
                        list.Add( unknownData );
                    }
                }
 
                return list;
            }
 
            static bool CheckHeader ( byte[] header )
            {
                if ( header == null || header.Length < 6 )
                    return false;
 
                for ( int i = 0; i < 6; ++i )
                    if ( header[i] != ValidHeader[i] )
                        return false;
 
                return true;
            }
        }

        static void Main ( string[] args )
        {
            const int COLUMNS = 16;
            var list = UnknownFileManager.ReadFile( @"X:\loc1.txt" );
 
            for ( int i = 0; i < list.Count; ++i )
            {
                var item = list[i];
                var length = item.BinaryData.Length;
                // Main info
                Console.WriteLine(
                    "{0}.\tName: {1}\r\n\tDate: {2}\r\n\tBinary: {3} (Mod2: {4}, Mod4: {5})\r\n\t",
                    (i + 1), item.Name, item.DateTime, length,
                    (length & 0x1) != 0x1 ? "Yes" : "No",
                    (length % 4) == 0x0 ? "Yes" : "No"
                    );
 
                DumpUnknownFields( item );
                DumpBin( item.BinaryData, COLUMNS );
            }
 
            Console.WriteLine( "Press any key to end..." );
            Console.ReadKey();
        }
 
        static void DumpUnknownFields ( UnknownFileData unknownFileData )
        {
            Console.WriteLine(
                "\tUNKNOWN_HEADER_MIDDLE:\r\n\t\tu0[4]: {0}\r\n\t\tu1[2]: {1}",
                unknownFileData.Unknown0.u0, unknownFileData.Unknown0.u1
                );
            Console.WriteLine(
                "\tUNKNOWN_HEADER_END (2 bytes all):\r\n\t\tu0: {0}\r\n\t\tu1: {1}\r\n\t\tu2: {2}\r\n\t\tu3: {3}\r\n\t\tu4: {4}\r\n",
                unknownFileData.Unknown1.u0, unknownFileData.Unknown1.u1, unknownFileData.Unknown1.u2, unknownFileData.Unknown1.u3,
                unknownFileData.Unknown1.u4
                );
        }
 
        static void DumpBin ( byte[] buffer, int columns )
        {
            var length = buffer.Length;
            var rows = length / columns;
            var csColor = ConsoleColor.White;
 
            // Table header
            Console.Write( "\t  №  | " );
 
            csColor = Console.ForegroundColor;
            Console.ForegroundColor = ConsoleColor.DarkGreen;
            for ( int j = 0; j < columns; ++j )
                Console.Write( "{0:X2} ", j );
            Console.ForegroundColor = csColor;
 
            Console.WriteLine( "|\r\n\t " + new string( '-', 7 + 3 * columns ) );
            // Table content
            // YYY | XX XX XX ...
            // YYY - row number
            // XX  - binary data
            for ( int j = 0; j < rows; ++j )
            {
                Console.Write( "\t " );
                csColor = Console.ForegroundColor;
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.Write( "{0:X3}", j * columns );
                Console.ForegroundColor = csColor;
                Console.Write( " | " );
 
                for ( int k = 0; k < columns; ++k )
                    Console.Write( "{0:X2} ", buffer[j * columns + k] );
                Console.Write( "|\r\n" );
            }
            // Last row
            // >>> | XX XX XX ...
            // >>> - end row
            // XX  - binary data
            if ( (rows = (length - (rows * columns))) > 0 && rows < columns )
            {
                Console.Write( "\t " );
                csColor = Console.ForegroundColor;
                Console.ForegroundColor = ConsoleColor.Red;
                Console.Write( ">>>" );
                Console.ForegroundColor = csColor;
                Console.Write( " | " );
 
                for ( int j = rows; j > 0; --j )
                    Console.Write( "{0:X2} ", buffer[length - j] );
                Console.WriteLine();
            }
 
            Console.WriteLine();
        }