System.IO.BinaryReader.ReadSByte()

Here are the examples of the csharp api System.IO.BinaryReader.ReadSByte() taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

170 Examples 7

19 Source : Pack.cs
with Apache License 2.0
from aequabit

public object[] Deserialize(byte[] data)
    {
        MemoryStream Stream = new MemoryStream(data);
        BinaryReader Reader = new BinaryReader(Stream, Encoding.UTF8);
        List<object> Items = new List<object>();
        byte Current = 0;
        byte Count = Reader.ReadByte();

        for (int I = 0; I <= Count - 1; I++)
        {
            Current = Reader.ReadByte();

            switch (Current)
            {
                case 0:
                    Items.Add(Reader.ReadBoolean());
                    break;
                case 1:
                    Items.Add(Reader.ReadByte());
                    break;
                case 2:
                    Items.Add(Reader.ReadBytes(Reader.ReadInt32()));
                    break;
                case 3:
                    Items.Add(Reader.ReadChar());
                    break;
                case 4:
                    Items.Add(Reader.ReadString().ToCharArray());
                    break;
                case 5:
                    Items.Add(Reader.ReadDecimal());
                    break;
                case 6:
                    Items.Add(Reader.ReadDouble());
                    break;
                case 7:
                    Items.Add(Reader.ReadInt32());
                    break;
                case 8:
                    Items.Add(Reader.ReadInt64());
                    break;
                case 9:
                    Items.Add(Reader.ReadSByte());
                    break;
                case 10:
                    Items.Add(Reader.ReadInt16());
                    break;
                case 11:
                    Items.Add(Reader.ReadSingle());
                    break;
                case 12:
                    Items.Add(Reader.ReadString());
                    break;
                case 13:
                    Items.Add(Reader.ReadUInt32());
                    break;
                case 14:
                    Items.Add(Reader.ReadUInt64());
                    break;
                case 15:
                    Items.Add(Reader.ReadUInt16());
                    break;
                case 16:
                    Items.Add(DateTime.FromBinary(Reader.ReadInt64()));
                    break;
            }
        }

        Reader.Close();
        return Items.ToArray();
    }

19 Source : Int8Data.cs
with GNU Affero General Public License v3.0
from aianlinb

public override void Read(BinaryReader reader) {
			Value = reader.ReadSByte();
		}

19 Source : LavalinkUtil.cs
with MIT License
from Aiko-IT-Systems

public static LavalinkTrack DecodeTrack(string track)
        {
            // https://github.com/sedmelluq/lavaplayer/blob/804cd1038229230052d9b1dee5e6d1741e30e284/main/src/main/java/com/sedmelluq/discord/lavaplayer/player/DefaultAudioPlayerManager.java#L63-L64
            const int TRACK_INFO_VERSIONED = 1;
            //const int TRACK_INFO_VERSION = 2;

            var raw = Convert.FromBase64String(track);

            var decoded = new LavalinkTrack
            {
                TrackString = track
            };

            using (var ms = new MemoryStream(raw))
            using (var br = new JavaBinaryReader(ms))
            {
                // https://github.com/sedmelluq/lavaplayer/blob/b0c536098c4f92e6d03b00f19221021f8f50b19b/main/src/main/java/com/sedmelluq/discord/lavaplayer/tools/io/MessageInput.java#L37-L39
                var messageHeader = br.ReadInt32();
                var messageFlags = (int) ((messageHeader & 0xC0000000L) >> 30);
                var messageSize = messageHeader & 0x3FFFFFFF;
                //if (messageSize != raw.Length)
                //    Warn($"Size conflict: {messageSize} but was {raw.Length}");

                // https://github.com/sedmelluq/lavaplayer/blob/804cd1038229230052d9b1dee5e6d1741e30e284/main/src/main/java/com/sedmelluq/discord/lavaplayer/player/DefaultAudioPlayerManager.java#L268

                // java bytes are signed
                // https://docs.oracle.com/javase/7/docs/api/java/io/DataInput.html#readByte()
                var version = (messageFlags & TRACK_INFO_VERSIONED) != 0 ? (br.ReadSByte() & 0xFF) : 1;
                //if (version != TRACK_INFO_VERSION)
                //    Warn($"Version conflict: Expected {TRACK_INFO_VERSION} but got {version}");

                decoded.replacedle = br.ReadJavaUtf8();

                decoded.Author = br.ReadJavaUtf8();

                decoded._length = br.ReadInt64();

                decoded.Identifier = br.ReadJavaUtf8();

                decoded.IsStream = br.ReadBoolean();

                var uri = br.ReadNullableString();
                decoded.Uri = uri != null && version >= 2 ? new Uri(uri) : null;
            }

            return decoded;
        }

19 Source : BsonReader.cs
with MIT License
from akaskela

private BsonType ReadType()
        {
            MovePosition(1);
            return (BsonType)_reader.ReadSByte();
        }

19 Source : BufferReader.cs
with GNU General Public License v3.0
from arycama

public sbyte[] ReadSByteArray(int length)
	{
		var bytes = new sbyte[length];
		for(var i = 0; i < length; i++)
			bytes[i] = ReadSByte();
		return bytes;
	}

19 Source : BinaryReaderExtensions.cs
with GNU General Public License v3.0
from arycama

public static sbyte[] ReadSByteArray(this BinaryReader reader, int length)
	{
		var bytes = new sbyte[length];
		for(var i = 0; i < length; i++)
			bytes[i] = reader.ReadSByte();
		return bytes;
	}

19 Source : CriUnpacker.cs
with MIT License
from Azukee

private List<Dictionary<string, object>> DecryptUTF(byte[] chunk)
        {
            if (Encoding.ASCII.GetString(chunk, 0, UTFMagic.Length) != UTFMagic)
                throw new InvalidMagicException();

            var chunkSize = (int) ToUInt32(chunk, 4);

            using (var ms = new MemoryStream(chunk, 8, chunkSize))
            using (var br = new BinaryReader(ms)) {
                var rowsOffset = br.ReadInt32BE();
                var stringsOffset = br.ReadInt32BE();
                var dataOffset = br.ReadInt32BE() + 8;
                br.ReadBytes(4);
                int columnCount = br.ReadInt16BE();
                int rowLength = br.ReadInt16BE();
                var rows = br.ReadInt32BE();

                var columns = new List<Column>(columnCount);
                for (var i = 0; i < columnCount; i++) {
                    var flags = br.ReadByte();
                    if (flags == 0) {
                        br.ReadBytes(3);
                        flags = br.ReadByte();
                    }

                    var nameOffset = stringsOffset + br.ReadInt32BE();
                    var posBefore = ms.Position;


                    ms.Seek(nameOffset, SeekOrigin.Begin);
                    columns.Add(new Column {Flags = (Flags) flags, Name = br.ReadCString()});
                    ms.Seek(posBefore, SeekOrigin.Begin);
                }

                //reading rows
                var returnTable = new List<Dictionary<string, object>>(rows);
                for (var i = 0; i < rows; i++) {
                    ms.Seek(rowsOffset + i * rowLength, SeekOrigin.Begin);

                    var row = new Dictionary<string, object>(columnCount);
                    returnTable.Add(row);
                    foreach (var column in columns) {
                        var storageFlag = column.Flags & Flags.StorageMask;
                        if (Flags.StorageNone == storageFlag || Flags.StorageZero == storageFlag || Flags.StorageConstant == storageFlag)
                            continue;
                        switch (column.Flags & Flags.Mask) {
                            case Flags.Byte:
                                row[column.Name] = (int) br.ReadByte();
                                break;
                            case Flags.SByte:
                                row[column.Name] = (int) br.ReadSByte();
                                break;
                            case Flags.UInt16:
                                row[column.Name] = (int) br.ReadUInt16BE();
                                break;
                            case Flags.Int16:
                                row[column.Name] = (int) br.ReadInt16BE();
                                break;
                            case Flags.UInt32:
                            case Flags.Int32:
                                row[column.Name] = br.ReadInt32BE();
                                break;
                            case Flags.UInt64:
                            case Flags.Int64:
                                row[column.Name] = br.ReadInt64BE();
                                break;
                            case Flags.Float32:
                                row[column.Name] = br.ReadSingleBE();
                                break;
                            case Flags.String: {
                                var posBefore = ms.Position;
                                var offset = stringsOffset + br.ReadInt32BE();
                                ms.Seek(offset, SeekOrigin.Begin);
                                row[column.Name] = br.ReadCString();
                                ms.Seek(posBefore, SeekOrigin.Begin);
                                break;
                            }
                            case Flags.Data: {
                                var offset = dataOffset + br.ReadInt32BE();
                                var length = br.ReadInt32BE();
                                row[column.Name] = chunk.Skip(offset).Take(length).ToArray();
                                break;
                            }
                        }
                    }
                }

                return returnTable;
            }
        }

19 Source : DBReaderExtensions.cs
with The Unlicense
from BAndysc

public static sbyte[] ReadSByte(this BinaryReader br, int count)
        {
            var arr = new sbyte[count];
            for (var i = 0; i < count; i++)
                arr[i] = br.ReadSByte();

            return arr;
        }

19 Source : DBReader.cs
with The Unlicense
from BAndysc

public void ReadIntoTable(ref DBEntry entry, BinaryReader dbReader, Dictionary<int, string> stringTable)
        {
            if (entry.Header.RecordCount == 0)
                return;

            var columnTypes = entry.Data.Columns.Cast<DataColumn>().Select(x => Type.GetTypeCode(x.DataType)).ToArray();
            //int[] padding = entry.GetPadding();

            var bits = entry.GetBits();
            int recordcount = Math.Max(entry.Header.OffsetLengths.Length, (int) entry.Header.RecordCount);

            uint recordsize = entry.Header.RecordSize + (uint) (entry.Header.HasIndexTable ? 4 : 0);
            if (entry.Header.InternalRecordSize > 0)
                recordsize = entry.Header.InternalRecordSize;

            entry.Data.BeginLoadData();

            for (uint i = 0; i < recordcount; i++)
            {
                //Offset map has variable record lengths
                if (entry.Header.IsTypeOf<HTFX>() || entry.Header.HasOffsetTable)
                    recordsize = (uint) entry.Header.OffsetLengths[i];

                //Store start position
                long offset = dbReader.BaseStream.Position;

                //Create row and add data
                DataRow row = entry.Data.NewRow();
                for (var j = 0; j < entry.Data.Columns.Count; j++)
                {
                    if (entry.Data.Columns[j].ExtendedProperties.ContainsKey(AutoGenerated))
                    {
                        row.SetField(entry.Data.Columns[j], entry.Data.Rows.Count + 1);
                        continue;
                    }

                    switch (columnTypes[j])
                    {
                        case TypeCode.Boolean:
                            row.SetField(entry.Data.Columns[j], dbReader.ReadBoolean());
                            break;
                        case TypeCode.SByte:
                            row.SetField(entry.Data.Columns[j], dbReader.ReadSByte());
                            break;
                        case TypeCode.Byte:
                            row.SetField(entry.Data.Columns[j], dbReader.ReadByte());
                            break;
                        case TypeCode.Int16:
                            row.SetField(entry.Data.Columns[j], dbReader.ReadInt16());
                            break;
                        case TypeCode.UInt16:
                            row.SetField(entry.Data.Columns[j], dbReader.ReadUInt16());
                            break;
                        case TypeCode.Int32:
                            row.SetField(entry.Data.Columns[j], dbReader.ReadInt32(bits[j]));
                            break;
                        case TypeCode.UInt32:
                            row.SetField(entry.Data.Columns[j], dbReader.ReadUInt32(bits[j]));
                            break;
                        case TypeCode.Int64:
                            row.SetField(entry.Data.Columns[j], dbReader.ReadInt64(bits[j]));
                            break;
                        case TypeCode.UInt64:
                            row.SetField(entry.Data.Columns[j], dbReader.ReadUInt64(bits[j]));
                            break;
                        case TypeCode.Single:
                            row.SetField(entry.Data.Columns[j], dbReader.ReadSingle());
                            break;
                        case TypeCode.String:
                            if (entry.Header.IsTypeOf<WDB>() || entry.Header.IsTypeOf<HTFX>() || entry.Header.HasOffsetTable)
                                row.SetField(entry.Data.Columns[j], dbReader.ReadStringNull());
                            else
                            {
                                int stindex = entry.Header.GetStringOffset(dbReader, j, i);
                                if (stringTable.ContainsKey(stindex))
                                    row.SetField(entry.Data.Columns[j], stringTable[stindex]);
                                else
                                {
                                    row.SetField(entry.Data.Columns[j], "String not found");
                                    ErrorMessage = "Strings not found in string table";
                                }
                            }

                            break;
                        default:
                            throw new Exception($"Unknown field type at column {i}.");
                    }

                    //dbReader.BaseStream.Position += padding[j];
                }

                entry.Data.Rows.Add(row);

                //Scrub to the end of the record
                if (dbReader.BaseStream.Position - offset < recordsize)
                    dbReader.BaseStream.Position += recordsize - (dbReader.BaseStream.Position - offset);
                else if (dbReader.BaseStream.Position - offset > recordsize)
                    throw new Exception("Definition exceeds record size");
            }

            //entry.Header.Clear();
            entry.Data.EndLoadData();
        }

19 Source : BasePacketReader.cs
with MIT License
from barncastle

public sbyte ReadInt8() => base.ReadSByte();

19 Source : BinaryObjectReader.cs
with MIT License
from BayatGames

public virtual object Read ( Type type )
		{
			object result = null;
			if ( type == null )
			{
				result = null;
			}
			else if ( type.IsPrimitive || type == typeof ( string ) || type == typeof ( decimal ) )
			{
				if ( type == typeof ( string ) )
				{
					result = m_Reader.ReadString ();
				}
				else if ( type == typeof ( decimal ) )
				{
					result = m_Reader.ReadDecimal ();
				}
				else if ( type == typeof ( short ) )
				{
					result = m_Reader.ReadInt16 ();
				}
				else if ( type == typeof ( int ) )
				{
					result = m_Reader.ReadInt32 ();
				}
				else if ( type == typeof ( long ) )
				{
					result = m_Reader.ReadInt64 ();
				}
				else if ( type == typeof ( ushort ) )
				{
					result = m_Reader.ReadUInt16 ();
				}
				else if ( type == typeof ( uint ) )
				{
					result = m_Reader.ReadUInt32 ();
				}
				else if ( type == typeof ( ulong ) )
				{
					result = m_Reader.ReadUInt64 ();
				}
				else if ( type == typeof ( double ) )
				{
					result = m_Reader.ReadDouble ();
				}
				else if ( type == typeof ( float ) )
				{
					result = m_Reader.ReadSingle ();
				}
				else if ( type == typeof ( byte ) )
				{
					result = m_Reader.ReadByte ();
				}
				else if ( type == typeof ( sbyte ) )
				{
					result = m_Reader.ReadSByte ();
				}
				else if ( type == typeof ( char ) )
				{
					result = m_Reader.ReadChar ();
				}
				else if ( type == typeof ( bool ) )
				{
					result = m_Reader.ReadBoolean ();
				}
			}
			else if ( type.IsEnum )
			{
				result = Enum.Parse ( type, m_Reader.ReadString () );
			}
			else if ( type == typeof ( DateTime ) )
			{
				result = DateTime.FromBinary ( m_Reader.ReadInt64 () );
			}
			else if ( type == typeof ( TimeSpan ) )
			{
				result = TimeSpan.Parse ( m_Reader.ReadString () );
			}
			else if ( type.IsArray )
			{
				Type elementType = type.GetElementType ();
				int rank = m_Reader.ReadInt32 ();
				int [] lengths = new int[rank];
				for ( int i = 0; i < rank; i++ )
				{
					lengths [ i ] = m_Reader.ReadInt32 ();
				}
				Array array = Array.CreateInstance ( elementType, lengths );
				int [] indices = new int[rank];
				for ( int i = 0; i < rank; i++ )
				{
					for ( int j = 0; j < lengths [ i ]; j++ )
					{
						indices [ i ] = j;
						array.SetValue ( Read ( elementType ), indices );
					}
				}
				result = array;
			}
			else if ( type.IsGenericType && type.GetGenericTypeDefinition () == typeof ( KeyValuePair<,> ) )
			{
				PropertyInfo key = type.GetProperty ( "Key" );
				PropertyInfo value = type.GetProperty ( "Value" );
				key.SetValue ( result, Read ( key.PropertyType ), BindingFlags.Default, null, null, null );
				value.SetValue ( result, Read ( value.PropertyType ), BindingFlags.Default, null, null, null );
			}
			else if ( type.IsGenericType && type.GetGenericTypeDefinition () == typeof ( List<> ) )
			{
				Type [] genericArgs = type.GetGenericArguments ();
				IList list = ( IList )type.GetConstructor ( Type.EmptyTypes ).Invoke ( null );
				int length = m_Reader.ReadInt32 ();
				for ( int i = 0; i < length; i++ )
				{
					list.Add ( Read ( genericArgs [ 0 ] ) );
				}
				result = list;
			}
			else if ( type.IsGenericType && type.GetGenericTypeDefinition () == typeof ( Dictionary<,> ) )
			{
				Type [] genericArgs = type.GetGenericArguments ();
				IDictionary dictionary = ( IDictionary )type.GetConstructor ( Type.EmptyTypes ).Invoke ( null );
				int length = m_Reader.ReadInt32 ();
				for ( int i = 0; i < length; i++ )
				{
					dictionary.Add ( Read ( genericArgs [ 0 ] ), Read ( genericArgs [ 1 ] ) );
				}
				result = dictionary;
			}
			else
			{
				result = ReadObject ( type );
			}
			if ( result is IDeserializationCallback )
			{
				( result as IDeserializationCallback ).OnDeserialization ( this );
			}
			return result;
		}

19 Source : BigEndianBinaryReader.cs
with GNU General Public License v3.0
from Bililive

public override sbyte ReadSByte() => base.ReadSByte();

19 Source : UserSetAvatarRequestHandler.cs
with GNU Lesser General Public License v2.1
from Blancworks

public async override Task<string> HandleMessage(WebSocketConnection connection, BinaryReader reader)
        {
            await base.HandleMessage(connection, reader);

            Guid id = ReadMinecraftUUIDFromBinaryReader(reader);
            bool shouldDelete = reader.ReadSByte() == 1;

            if (shouldDelete)
                await connection.connectionUser.TryDeleteCurrentAvatar();
            await connection.connectionUser.SetCurrentAvatar(id);

            return string.Empty;
        }

19 Source : WebSocketConnection.cs
with GNU Lesser General Public License v2.1
from Blancworks

public async Task MessageLoop()
        {
            byte[] messageData = await GetNextMessage();

            while (messageData.Length != 0 && socket.CloseStatus != WebSocketCloseStatus.Empty)
            {
                //Create memory stream and binary reader from message array
                using (MemoryStream ms = new MemoryStream(messageData))
                {
                    using (BinaryReader br = new BinaryReader(ms, Encoding.UTF8))
                    {
                        int handlerID = br.ReadSByte() - sbyte.MinValue - 1;

                        //Get the handler by ID
                        if (messageHandlers.Count > handlerID)
                        {
                            MessageHandler handler = messageHandlers[handlerID];
                            Logger.LogMessage("Handling message with Handler ID:" + handlerID + " and protocol name " + handler.ProtocolName);

                            try
                            {
                                await handler.HandleMessage(this, br);
                                Logger.LogMessage("Handled.");
                            }
                            catch (Exception e)
                            {
                                Logger.LogMessage(e.ToString());
                            }
                        }
                        else
                        {
                            Logger.LogMessage("No message with Handler ID:" + handlerID);
                        }
                    }
                }

                messageData = await GetNextMessage();

                //Check message rate limit.
                if (!messageRateLimiter.TryTakePoints(1))
                {
                    SendMessage(new ErrorMessageSender(ErrorMessageSender.MESSAGE_RATE_LIMIT));
                    continue;
                }
            }
        }

19 Source : SilverlightSerializer.cs
with MIT License
from CalciumFramework

private static object ReadValue(BinaryReader reader, Type tp)
		{

			if (tp == typeof(string))
			{
				var retString = reader.ReadString();

				return retString == "~~NULL~~"
						   ? null
						   : retString;
			}
			if (tp == typeof(bool))
				return reader.ReadChar() == 'Y';
			if (tp == typeof(decimal))
			{
				var array = DeserializeObject(reader, typeof(int[])) as int[];
				return new Decimal(array);
			}
			if (tp == typeof(DateTime))
				return new DateTime(reader.ReadInt64());
			if (tp == typeof(TimeSpan))
				return new TimeSpan(reader.ReadInt64());
			if (tp == typeof(float))
				return reader.ReadSingle();
			if (tp == typeof(char))
				return reader.ReadChar();
			if (tp == typeof(ushort))
				return reader.ReadUInt16();
			if (tp == typeof(double))
				return reader.ReadDouble();
			if (tp == typeof(ulong))
				return reader.ReadUInt64();
			if (tp == typeof(int))
				return reader.ReadInt32();
			if (tp == typeof(uint))
				return reader.ReadUInt32();
			if (tp == typeof(byte))
				return reader.ReadByte();
			if (tp == typeof(long))
				return reader.ReadInt64();
			if (tp == typeof(short))
				return reader.ReadInt16();
			if (tp == typeof(sbyte))
				return reader.ReadSByte();
			if (tp == typeof(Guid))
				return new Guid(reader.ReadString());
			return reader.ReadInt32();
		}

19 Source : wzreader.cs
with BSD 2-Clause "Simplified" License
from chengse66

internal T read<T>() where T : struct
	{
		if (typeof(sbyte) == typeof(T))
			return (T)(object)reader.ReadSByte();
		if (typeof(byte) == typeof(T))
			return (T)(object)reader.ReadByte();
		if (typeof(short) == typeof(T))
			return (T)(object)reader.ReadInt16();
		if (typeof(ushort) == typeof(T))
			return (T)(object)reader.ReadUInt16();
		if (typeof(int) == typeof(T))
			return (T)(object)reader.ReadInt32();
		if (typeof(uint) == typeof(T))
			return (T)(object)reader.ReadUInt32();
		if (typeof(long) == typeof(T))
			return (T)(object)reader.ReadInt64();
		if (typeof(ulong) == typeof(T))
			return (T)(object)reader.ReadUInt64();
		if (typeof(float) == typeof(T))
			return (T)(object)reader.ReadSingle();
		if (typeof(double) == typeof(T))
			return (T)(object)reader.ReadDouble();

		return default(T);
	}

19 Source : SampleHeaderBuilder.cs
with GNU General Public License v3.0
from ciribob

public override SampleHeader Read(BinaryReader br)
        {
            SampleHeader sh = new SampleHeader();
            var s = br.ReadBytes(20);

            sh.SampleName = ByteEncoding.Instance.GetString(s, 0, s.Length);
            sh.Start = br.ReadUInt32();
            sh.End = br.ReadUInt32();
            sh.StartLoop = br.ReadUInt32();
            sh.EndLoop = br.ReadUInt32();
            sh.SampleRate = br.ReadUInt32();
            sh.OriginalPitch = br.ReadByte();
            sh.PitchCorrection = br.ReadSByte();
            sh.SampleLink = br.ReadUInt16();
            sh.SFSampleLink = (SFSampleLink) br.ReadUInt16();
            data.Add(sh);
            return sh;
        }

19 Source : BinarySByteSerializer.cs
with MIT License
from CityOfZion

public object Deserialize(IBinarySerializer deserializer, BinaryReader reader, Type type, BinarySerializerSettings settings = null)
        {
            return reader.ReadSByte();
        }

19 Source : BsonReader.cs
with MIT License
from CragonGame

private BsonType ReadType()
    {
      MovePosition(1);
      return (BsonType)_reader.ReadSByte();
    }

19 Source : BGIFont.cs
with MIT License
from cwensley

public void Load(Stream stream)
		{
			BinaryReader br = new BinaryReader(stream);
			byte b;
			do
			{
				b = br.ReadByte();
			} while (b != 0x1a);
			
			// fheader
			headerSize = br.ReadUInt16();
			byte[] name = br.ReadBytes(4);
			fontName = Encoding.ASCII.GetString(name);
			fontSize = br.ReadUInt16();
			fontMajor = br.ReadByte();
			fontMinor = br.ReadByte();
			minMajor = br.ReadByte();
			minMinor = br.ReadByte();

			stream.Position = headerSize;

			// header
			sig = br.ReadByte();
			characterCount = br.ReadInt16();
			br.ReadByte(); // unused byte
			first = br.ReadByte();
			characterOffset = br.ReadInt16();
			scanFlag = br.ReadByte();
			org_to_cap = br.ReadSByte();
			org_to_base = br.ReadSByte();
			org_to_dec = br.ReadSByte();
			byte[] shortName = br.ReadBytes(4);
			shortFontName = Encoding.ASCII.GetString(shortName);
			br.ReadByte(); // unused byte

			// read offset table
			Int16[] fontOffsets = new Int16[256];
			for (int i=first; i<first+characterCount; i++)
			{
				fontOffsets[i] = br.ReadInt16();
			}

			// read character width table
			byte[] charWidths = new byte[256];
			for (int i=first; i<first+characterCount; i++)
			{
				charWidths[i] = br.ReadByte();
			}

			characters = new BGICharacter[256];

			long start = stream.Position;

			for (int i=first; i<first+characterCount; i++)
			{
				stream.Seek(start + fontOffsets[i], SeekOrigin.Begin);
				characters[i] = new BGICharacter(this, stream, charWidths[i]);
			}

			capitalHeight = 40;
			baseHeight = 0;
			descenderHeight = -7;
			BGICharacter bc;
			bc = characters[(int)'E'];
			if (bc == null) bc = characters[(int)'M'];
			if (bc != null)
			{
				bool isFirst = true;
				int min = 0;
				int max = 0;
				foreach (BGICharacter.Stroke s in bc.Strokes)
				{
					if (isFirst || max < s.y) max = s.y;
					if (isFirst || min > s.y) min = s.y;
					isFirst = false;
				}
				capitalHeight = Math.Abs(max);
				baseHeight = Math.Abs(min);
			}
			lowerCaseHeight = capitalHeight/2;

			bc = characters[(int)'q'];
			if (bc != null)
			{
				bool isFirst = true;
				int min = 0;
				int max = 0;
				foreach (BGICharacter.Stroke s in bc.Strokes)
				{
					if (isFirst || max < s.y) max = s.y;
					if (isFirst || min > s.y) min = s.y;
					isFirst = false;
				}
				descenderHeight = Math.Abs(min);
			}

			bc = characters[(int)'x'];
			if (bc != null)
			{
				bool isFirst = true;
				int min = 0;
				int max = 0;
				foreach (BGICharacter.Stroke s in bc.Strokes)
				{
					if (isFirst || max < s.y) max = s.y;
					if (isFirst || min > s.y) min = s.y;
					isFirst = false;
				}
				lowerCaseHeight = Math.Abs(max);
			}
			
			//Console.WriteLine("Font {0}", this);
			loaded = true;
		}

19 Source : EnumReaderWriter.cs
with MIT License
from CyAScott

public static object ReadEnum(this BinaryReader reader, Type type = null)
        {
            var enumType = type ?? reader.ReadType();

            var integralType = Enum.GetUnderlyingType(enumType);
            object integralValue;

            if (integralType == typeof(int))
            {
                integralValue = reader.ReadInt32();
            }
            else if (integralType == typeof(byte))
            {
                integralValue = reader.ReadByte();
            }
            else if (integralType == typeof(uint))
            {
                integralValue = reader.ReadUInt32();
            }
            else if (integralType == typeof(long))
            {
                integralValue = reader.ReadInt64();
            }
            else if (integralType == typeof(ulong))
            {
                integralValue = reader.ReadUInt64();
            }
            else if (integralType == typeof(sbyte))
            {
                integralValue = reader.ReadSByte();
            }
            else if (integralType == typeof(short))
            {
                integralValue = reader.ReadInt16();
            }
            else if (integralType == typeof(ushort))
            {
                integralValue = reader.ReadUInt16();
            }
            else
            {
                //this should not be possible based on the limitations of the enum type
                throw new InvalidOperationException("Unable to serialize the enum value.");
            }

            return Enum.ToObject(enumType, integralValue);
        }

19 Source : ObjectReaderWriter.cs
with MIT License
from CyAScott

public static async Task<object> ReadObject(this BinaryReader reader, ObjectType objectType, IResolveProxyIds resolver)
        {
            switch (objectType)
            {
                case ObjectType.Array:
                    return await reader.ReadArray(resolver).ConfigureAwait(false);

                case ObjectType.Serializable:
                    return await reader.ReadSerializable(resolver).ConfigureAwait(false);

                case ObjectType.Enum:
                    return reader.ReadEnum();

                case ObjectType.Null:
                    return null;

                case ObjectType.Proxy:
                    var id = reader.ReadInt64();
                    return resolver.TryToGetInstance(id, out var instance) ? instance : null;

                case ObjectType.Type:
                    return reader.ReadType();

                case ObjectType.DateTime:
                    return reader.ReadDateTime();

                case ObjectType.Guid:
                    return await reader.ReadGuid().ConfigureAwait(false);

                case ObjectType.TimeSpan:
                    return reader.ReadTimeSpan();

                case ObjectType.Byte:
                    return reader.ReadByte();
                case ObjectType.Bytes:
                    var bytes = new byte[reader.ReadInt32()];
                    var byteIndex = 0;
                    while (byteIndex < bytes.Length)
                    {
                        byteIndex += await reader.BaseStream.ReadAsync(bytes, byteIndex, bytes.Length - byteIndex).ConfigureAwait(false);
                    }
                    return bytes;

                case ObjectType.Boolean:
                    return reader.ReadBoolean();

                case ObjectType.Char:
                    return reader.ReadChar();

                case ObjectType.Decimal:
                    return reader.ReadDecimal();

                case ObjectType.Double:
                    return reader.ReadDouble();

                case ObjectType.Float:
                    return reader.ReadSingle();

                case ObjectType.Int:
                    return reader.ReadInt32();

                case ObjectType.Long:
                    return reader.ReadInt64();

                case ObjectType.SByte:
                    return reader.ReadSByte();

                case ObjectType.Short:
                    return reader.ReadInt16();

                case ObjectType.Str:
                    return reader.ReadString();

                case ObjectType.UInt:
                    return reader.ReadUInt32();

                case ObjectType.ULong:
                    return reader.ReadUInt64();

                case ObjectType.UShort:
                    return reader.ReadUInt16();

                default:
                    throw new ArgumentOutOfRangeException();
            }
        }

19 Source : ByteBuffer.cs
with GNU General Public License v3.0
from CypherCore

public sbyte ReadInt8()
        {
            ResetBitPos();
            return readStream.ReadSByte();
        }

19 Source : Wire.cs
with Apache License 2.0
from danielcrenna

private static object ReadValue(this Type type, BinaryReader br, ITypeResolver typeResolver)
		{
			while (true)
			{
				readValue:

				if (type == null)
					throw new NullReferenceException();

				if (type == typeof(string))
					return br.ReadIsNull() ? default : br.ReadString();
				if (type == typeof(bool))
					return BuiltIns.ReadBoolean(br);
				if (type == typeof(int))
					return br.ReadInt32();
				if (type == typeof(long))
					return br.ReadInt64();
				if (type == typeof(float))
					return br.ReadSingle();
				if (type == typeof(double))
					return br.ReadDouble();
				if (type == typeof(decimal))
					return br.ReadDecimal();
				if (type == typeof(short))
					return br.ReadInt16();
				if (type == typeof(uint))
					return br.ReadUInt32();
				if (type == typeof(ulong))
					return br.ReadUInt64();
				if (type == typeof(ushort))
					return br.ReadUInt16();
				if (type == typeof(byte))
					return br.ReadByte();
				if (type == typeof(sbyte))
					return br.ReadSByte();
				if (type == typeof(char))
					return br.ReadChar();

				if (type == typeof(byte?))
					return br.ReadIsNull() ? default : br.ReadByte();
				if (type == typeof(sbyte?))
					return br.ReadIsNull() ? default : br.ReadSByte();
				if (type == typeof(bool?))
					return br.ReadIsNull() ? default : br.ReadBoolean();
				if (type == typeof(short?))
					return br.ReadIsNull() ? default : br.ReadInt16();
				if (type == typeof(ushort?))
					return br.ReadIsNull() ? default : br.ReadUInt16();
				if (type == typeof(int?))
					return br.ReadIsNull() ? default : br.ReadInt32();
				if (type == typeof(uint?))
					return br.ReadIsNull() ? default : br.ReadUInt32();
				if (type == typeof(long?))
					return br.ReadIsNull() ? default : br.ReadInt64();
				if (type == typeof(ulong?))
					return br.ReadIsNull() ? default : br.ReadUInt64();
				if (type == typeof(float?))
					return br.ReadIsNull() ? default : br.ReadSingle();
				if (type == typeof(double?))
					return br.ReadIsNull() ? default : br.ReadDouble();
				if (type == typeof(decimal?))
					return br.ReadIsNull() ? default : br.ReadDecimal();
				if (type == typeof(char?))
					return br.ReadIsNull() ? default : br.ReadChar();

				if (type == typeof(char[]))
					return br.ReadIsNull() ? null : ReadCharArray(br);
				if (type == typeof(byte[]))
					return br.ReadIsNull() ? null : ReadByteArray(br);

				if (type == typeof(TimeSpan))
					return br.ReadTimeSpan();
				if (type == typeof(DateTimeOffset))
					return br.ReadDateTimeOffset();
				if (type == typeof(DateTime))
					return br.ReadDateTime(typeResolver);

				if (type == typeof(TimeSpan?))
					return br.ReadIsNull() ? default : br.ReadTimeSpan();
				if (type == typeof(DateTimeOffset?))
					return br.ReadIsNull() ? null : br.ReadDateTimeOffset();
				if (type == typeof(DateTime?))
					return br.ReadIsNull() ? null : ReadDateTime(br, typeResolver);

				if (typeof(IDictionary<,>).IsreplacedignableFromGeneric(type))
				{
					if (br.ReadIsNull())
						return null;

					var method = ReadTypedDictionaryMethod;
					if (method == null)
						throw new NullReferenceException();

					var genericMethod = method.MakeGenericMethod(type.GenericTypeArguments);
					return genericMethod.Invoke(null, new object [] { br, typeResolver });
				}

				if (typeof(IList<>).IsreplacedignableFromGeneric(type))
					return br.ReadIsNull() ? null : br.ReadTypedList(type, typeResolver);
				
				if (typeof(IList).IsreplacedignableFrom(type))
					return br.ReadIsNull() ? null : br.ReadList(type, typeResolver);

				if (type.IsEnum)
				{
					type = GetEnumType(type);
					goto readValue;
				}

				if (Nullable.GetUnderlyingType(type) != null)
				{
					if (!br.ReadIsNull())
					{
						type = Nullable.GetUnderlyingType(type);
						goto readValue;
					}

					return null;
				}

				return br.ReadObject(type, typeResolver);
			}
		}

19 Source : TR2FileReadUtilities.cs
with MIT License
from DanzaG

public static TRRoomSector ReadRoomSector(BinaryReader reader)
        {
            return new TRRoomSector
            {
                FDIndex = reader.ReadUInt16(),
                BoxIndex = reader.ReadUInt16(),
                RoomBelow = reader.ReadByte(),
                Floor = reader.ReadSByte(),
                RoomAbove = reader.ReadByte(),
                Ceiling = reader.ReadSByte()
            };
        }

19 Source : ResourcesFile.cs
with MIT License
from deepakkumar1984

private object LoadObjectV1(int dataOffset)
		{
			Debug.replacedert(System.Threading.Monitor.IsEntered(reader));
			reader.Seek(dataSectionPosition + dataOffset, SeekOrigin.Begin);
			int typeIndex = reader.Read7BitEncodedInt();
			if (typeIndex == -1)
				return null;
			string typeName = FindType(typeIndex);
			int comma = typeName.IndexOf(',');
			if (comma > 0) {
				// strip replacedembly name
				typeName = typeName.Substring(0, comma);
			}
			switch (typeName) {
				case "System.String":
					return reader.ReadString();
				case "System.Byte":
					return reader.ReadByte();
				case "System.SByte":
					return reader.ReadSByte();
				case "System.Int16":
					return reader.ReadInt16();
				case "System.UInt16":
					return reader.ReadUInt16();
				case "System.Int32":
					return reader.ReadInt32();
				case "System.UInt32":
					return reader.ReadUInt32();
				case "System.Int64":
					return reader.ReadInt64();
				case "System.UInt64":
					return reader.ReadUInt64();
				case "System.Single":
					return reader.ReadSingle();
				case "System.Double":
					return reader.ReadDouble();
				case "System.DateTime":
					// Ideally we should use DateTime's ToBinary & FromBinary,
					// but we can't for compatibility reasons.
					return new DateTime(reader.ReadInt64());
				case "System.TimeSpan":
					return new TimeSpan(reader.ReadInt64());
				case "System.Decimal":
					int[] bits = new int[4];
					for (int i = 0; i < bits.Length; i++)
						bits[i] = reader.ReadInt32();
					return new decimal(bits);
				default:
					return new ResourceSerializedObject(FindType(typeIndex), this, reader.BaseStream.Position);
			}
		}

19 Source : ResourcesFile.cs
with MIT License
from deepakkumar1984

private object LoadObjectV2(int dataOffset)
		{
			Debug.replacedert(System.Threading.Monitor.IsEntered(reader));
			reader.Seek(dataSectionPosition + dataOffset, SeekOrigin.Begin);
			var typeCode = (ResourceTypeCode)reader.Read7BitEncodedInt();
			switch (typeCode) {
				case ResourceTypeCode.Null:
					return null;

				case ResourceTypeCode.String:
					return reader.ReadString();

				case ResourceTypeCode.Boolean:
					return reader.ReadBoolean();

				case ResourceTypeCode.Char:
					return (char)reader.ReadUInt16();

				case ResourceTypeCode.Byte:
					return reader.ReadByte();

				case ResourceTypeCode.SByte:
					return reader.ReadSByte();

				case ResourceTypeCode.Int16:
					return reader.ReadInt16();

				case ResourceTypeCode.UInt16:
					return reader.ReadUInt16();

				case ResourceTypeCode.Int32:
					return reader.ReadInt32();

				case ResourceTypeCode.UInt32:
					return reader.ReadUInt32();

				case ResourceTypeCode.Int64:
					return reader.ReadInt64();

				case ResourceTypeCode.UInt64:
					return reader.ReadUInt64();

				case ResourceTypeCode.Single:
					return reader.ReadSingle();

				case ResourceTypeCode.Double:
					return reader.ReadDouble();

				case ResourceTypeCode.Decimal:
					return reader.ReadDecimal();

				case ResourceTypeCode.DateTime:
					// Use DateTime's ToBinary & FromBinary.
					long data = reader.ReadInt64();
					return DateTime.FromBinary(data);

				case ResourceTypeCode.TimeSpan:
					long ticks = reader.ReadInt64();
					return new TimeSpan(ticks);

				// Special types
				case ResourceTypeCode.ByteArray: {
						int len = reader.ReadInt32();
						if (len < 0) {
							throw new BadImageFormatException("Resource with negative length");
						}
						return reader.ReadBytes(len);
					}

				case ResourceTypeCode.Stream: {
						int len = reader.ReadInt32();
						if (len < 0) {
							throw new BadImageFormatException("Resource with negative length");
						}
						byte[] bytes = reader.ReadBytes(len);
						return new MemoryStream(bytes, writable: false);
					}

				default:
					if (typeCode < ResourceTypeCode.StartOfUserTypes) {
						throw new BadImageFormatException("Invalid typeCode");
					}
					return new ResourceSerializedObject(FindType(typeCode - ResourceTypeCode.StartOfUserTypes), this, reader.BaseStream.Position);
			}
		}

19 Source : NDArray.cs
with Apache License 2.0
from deepakkumar1984

public static NDArrayList LoadNpz(string file)
        {
            NDArrayList result = new NDArrayList();
            using (ZipArchive zip = ZipFile.OpenRead(file))
            {
                foreach (ZipArchiveEntry entry in zip.Entries)
                {
                    Stream fs = entry.Open();
                    BinaryReader reader = new BinaryReader(fs);
                    var magic = reader.ReadChars(6);
                    var maj = reader.ReadByte();
                    var min = reader.ReadByte();
                    int headerLength = reader.ReadUInt16();
                    string header = new string(reader.ReadChars(headerLength)).Trim();
                    string mark = "'descr': '";
                    int s = header.IndexOf(mark) + mark.Length;
                    int e = header.IndexOf("'", s + 1);
                    string type = header.Substring(s, e - s);

                    DType dtype = GetNpyType(type);
                    mark = "'fortran_order': ";
                    s = header.IndexOf(mark) + mark.Length;
                    e = header.IndexOf(",", s + 1);
                    bool fortran = bool.Parse(header.Substring(s, e - s));

                    if (fortran)
                        throw new Exception();

                    mark = "'shape': (";
                    s = header.IndexOf(mark) + mark.Length;
                    e = header.IndexOf(")", s + 1);
                    var shapeSplit = header.Substring(s, e - s).Split(',');
                    List<int> shapeInt = new List<int>();
                    foreach (var element in shapeSplit)
                    {
                        if (!string.IsNullOrWhiteSpace(element))
                        {
                            shapeInt.Add(Convert.ToInt32(element));
                        }
                    }

                    Shape shape = new Shape(shapeInt);
                    if (dtype == DType.Int32)
                    {
                        List<int> data = new List<int>();
                        for (int i = 0; i < shape.Size; i++)
                        {
                            data.Add(reader.ReadInt32());
                        }

                        var x = nd.Array(data.ToArray()).AsType(dtype).Reshape(shape);
                        result.Add(x);
                    }
                    else if (dtype == DType.Int8)
                    {
                        List<sbyte> data = new List<sbyte>();
                        for (int i = 0; i < shape.Size; i++)
                        {
                            data.Add(reader.ReadSByte());
                        }

                        var x = nd.Array(data.ToArray()).AsType(dtype).Reshape(shape);
                        result.Add(x);
                    }
                    else if (dtype == DType.Int64)
                    {
                        List<long> data = new List<long>();
                        for (int i = 0; i < shape.Size; i++)
                        {
                            data.Add(reader.ReadSByte());
                        }

                        var x = nd.Array(data.ToArray()).AsType(dtype).Reshape(shape);
                        result.Add(x);
                    }
                    else if (dtype == DType.Float32)
                    {
                        List<float> data = new List<float>();
                        for (int i = 0; i < shape.Size; i++)
                        {
                            data.Add(reader.ReadSByte());
                        }

                        var x = nd.Array(data.ToArray()).AsType(dtype).Reshape(shape);
                        result.Add(x);
                    }
                    else if (dtype == DType.Float64)
                    {
                        List<double> data = new List<double>();
                        for (int i = 0; i < shape.Size; i++)
                        {
                            data.Add(reader.ReadSByte());
                        }

                        var x = nd.Array(data.Select(i => (float)i).ToArray()).AsType(dtype).Reshape(shape).AsType(dtype);
                        result.Add(x);
                    }
                    else if (dtype == DType.UInt8)
                    {
                        var data = reader.ReadBytes(Convert.ToInt32(shape.Size));

                        var x = nd.Array(data.Select(i => (float)i).ToArray()).Reshape(shape).AsType(dtype);
                        result.Add(x);
                    }
                }
            }

            return result;
        }

19 Source : BufferStream.cs
with MIT License
from dereksorensen

public sbyte GetSByte()
        {
            return _reader.ReadSByte();
        }

19 Source : BinarySerializer.cs
with Apache License 2.0
from deveel

private static object ReadPrimitive(BinaryReader reader, bool isNull, out Type objectType) {
			var nullable = reader.ReadBoolean();
			var typeCode = (PrimitiveTypeCode) reader.ReadByte();
			objectType = SerializerUtil.GetObjectType(typeCode);

			if (nullable)
				objectType = typeof(Nullable<>).MakeGenericType(objectType);

			if (isNull)
				return null;

			switch (typeCode) {
				case PrimitiveTypeCode.Boolean:
					return reader.ReadBoolean();
				case PrimitiveTypeCode.Byte:
					return reader.ReadByte();
				case PrimitiveTypeCode.SByte:
					return reader.ReadSByte();
				case PrimitiveTypeCode.Int16:
					return reader.ReadInt16();
				case PrimitiveTypeCode.UInt16:
					return reader.ReadUInt16();
				case PrimitiveTypeCode.Int32:
					return reader.ReadInt32();
				case PrimitiveTypeCode.UInt32:
					return reader.ReadUInt32();
				case PrimitiveTypeCode.Int64:
					return reader.ReadInt64();
				case PrimitiveTypeCode.UInt64:
					return reader.ReadUInt64();
				case PrimitiveTypeCode.Single:
					return reader.ReadSingle();
				case PrimitiveTypeCode.Double:
					return reader.ReadDouble();
				case PrimitiveTypeCode.Char:
					return reader.ReadChar();
				case PrimitiveTypeCode.String:
					return reader.ReadString();
				default:
					throw new SerializationException();
			}
		}

19 Source : BinaryReaderWriterExtensions.cs
with MIT License
from diamondo25

private static string DecodeString(this BinaryReader reader)
        {
            // unicode/ascii switch
            var len = reader.ReadSByte();
            if (len == 0) return "";

            var unicode = len > 0;

            if (unicode) return reader.DecodeStringUnicode(len);
            else return reader.DecodeStringASCII(len);
        }

19 Source : BinaryReaderWriterExtensions.cs
with MIT License
from diamondo25

public static int ReadCompressedInt(this BinaryReader reader)
        {
            var x = reader.ReadSByte();
            if (x == -128) return reader.ReadInt32();
            return x;
        }

19 Source : BinaryReaderWriterExtensions.cs
with MIT License
from diamondo25

public static long ReadCompressedLong(this BinaryReader reader)
        {
            var x = reader.ReadSByte();
            if (x == -128) return reader.ReadInt64();
            return x;
        }

19 Source : ArchiveReader.cs
with MIT License
from diamondo25

private string DecodeString()
        {
            // unicode/ascii switch
            var len = ReadSByte();
            if (len == 0) return "";

            var unicode = len > 0;

            if (unicode) return DecodeStringUnicode(len);
            else return DecodeStringASCII(len);
        }

19 Source : BinaryReaderExt.cs
with MIT License
from Dnawrkshp

public static object ReadObject(this BinaryReader reader, Type type)
        {
            if (type.GetInterface("IStreamSerializer") != null)
            {
                var result = (IStreamSerializer)Activator.CreateInstance(type);
                result.Deserialize(reader);
                return result;
            }
            else if (type.IsEnum)
                return reader.ReadObject(type.GetEnumUnderlyingType()); //Enum.Parse(type, type.GetEnumName(reader.ReadObject(type.GetEnumUnderlyingType())));
            else if (type == typeof(bool))
                return reader.ReadBoolean();
            else if (type == typeof(byte))
                return reader.ReadByte();
            else if (type == typeof(sbyte))
                return reader.ReadSByte();
            else if (type == typeof(char))
                return reader.ReadChar();
            else if (type == typeof(short))
                return reader.ReadInt16();
            else if (type == typeof(ushort))
                return reader.ReadUInt16();
            else if (type == typeof(int))
                return reader.ReadInt32();
            else if (type == typeof(uint))
                return reader.ReadUInt32();
            else if (type == typeof(long))
                return reader.ReadInt64();
            else if (type == typeof(ulong))
                return reader.ReadUInt64();
            else if (type == typeof(float))
                return reader.ReadSingle();
            else if (type == typeof(double))
                return reader.ReadDouble();
            else if (type == typeof(string))
                return reader.ReadString();

            return null;
        }

19 Source : NbtByte.cs
with MIT License
from dotnetGame

public NbtTag Deserialize(BinaryReader br, bool requireName)
            {
                string name = null;
                if (requireName)
                {
                    name = br.ReadTagString();
                }

                var value = br.ReadSByte();
                return new NbtByte(value, name);
            }

19 Source : TypeTreeHelper.cs
with GNU General Public License v3.0
from ds5678

private static void ReadStringValue(StringBuilder sb, List<TypeTreeNode> m_Nodes, BinaryReader reader, ref int i)
		{
			var m_Node = m_Nodes[i];
			var level = m_Node.Level;
			var varTypeStr = m_Node.Type;
			var varNameStr = m_Node.Name;
			object value = null;
			var append = true;
			var align = m_Node.MetaFlag.IsAlignBytes();
			switch (varTypeStr)
			{
				case "SInt8":
					value = reader.ReadSByte();
					break;
				case "UInt8":
				case "char":
					value = reader.ReadByte();
					break;
				case "short":
				case "SInt16":
					value = reader.ReadInt16();
					break;
				case "UInt16":
				case "unsigned short":
					value = reader.ReadUInt16();
					break;
				case "int":
				case "SInt32":
					value = reader.ReadInt32();
					break;
				case "UInt32":
				case "unsigned int":
				case "Type*":
					value = reader.ReadUInt32();
					break;
				case "long long":
				case "SInt64":
					value = reader.ReadInt64();
					break;
				case "UInt64":
				case "unsigned long long":
				case "FileSize":
					value = reader.ReadUInt64();
					break;
				case "float":
					value = reader.ReadSingle();
					break;
				case "double":
					value = reader.ReadDouble();
					break;
				case "bool":
					value = reader.ReadBoolean();
					break;
				case "string":
					append = false;
					var str = reader.ReadAlignedString();
					sb.AppendFormat("{0}{1} {2} = \"{3}\"\r\n", (new string('\t', level)), varTypeStr, varNameStr, str);
					i += 3;
					break;
				case "map":
					{
						if ((m_Nodes[i + 1].MetaFlag.IsAlignBytes()))
							align = true;
						append = false;
						sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level)), varTypeStr, varNameStr);
						sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level + 1)), "Array", "Array");
						var size = reader.ReadInt32();
						sb.AppendFormat("{0}{1} {2} = {3}\r\n", (new string('\t', level + 1)), "int", "size", size);
						var map = GetNodes(m_Nodes, i);
						i += map.Count - 1;
						var first = GetNodes(map, 4);
						var next = 4 + first.Count;
						var second = GetNodes(map, next);
						for (int j = 0; j < size; j++)
						{
							sb.AppendFormat("{0}[{1}]\r\n", (new string('\t', level + 2)), j);
							sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level + 2)), "pair", "data");
							int tmp1 = 0;
							int tmp2 = 0;
							ReadStringValue(sb, first, reader, ref tmp1);
							ReadStringValue(sb, second, reader, ref tmp2);
						}
						break;
					}
				case "TypelessData":
					{
						append = false;
						var size = reader.ReadInt32();
						reader.ReadBytes(size);
						i += 2;
						sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level)), varTypeStr, varNameStr);
						sb.AppendFormat("{0}{1} {2} = {3}\r\n", (new string('\t', level)), "int", "size", size);
						break;
					}
				default:
					{
						if (i < m_Nodes.Count - 1 && m_Nodes[i + 1].Type == "Array") //Array
						{
							if (m_Nodes[i + 1].MetaFlag.IsAlignBytes())
								align = true;
							append = false;
							sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level)), varTypeStr, varNameStr);
							sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level + 1)), "Array", "Array");
							var size = reader.ReadInt32();
							sb.AppendFormat("{0}{1} {2} = {3}\r\n", (new string('\t', level + 1)), "int", "size", size);
							var vector = GetNodes(m_Nodes, i);
							i += vector.Count - 1;
							for (int j = 0; j < size; j++)
							{
								sb.AppendFormat("{0}[{1}]\r\n", (new string('\t', level + 2)), j);
								int tmp = 3;
								ReadStringValue(sb, vector, reader, ref tmp);
							}
							break;
						}
						else //Clreplaced
						{
							append = false;
							sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level)), varTypeStr, varNameStr);
							var @clreplaced = GetNodes(m_Nodes, i);
							i += @clreplaced.Count - 1;
							for (int j = 1; j < @clreplaced.Count; j++)
							{
								ReadStringValue(sb, @clreplaced, reader, ref j);
							}
							break;
						}
					}
			}
			if (append)
				sb.AppendFormat("{0}{1} {2} = {3}\r\n", (new string('\t', level)), varTypeStr, varNameStr, value);
			if (align)
				reader.AlignStream();
		}

19 Source : TypeTreeHelper.cs
with GNU General Public License v3.0
from ds5678

private static object ReadValue(List<TypeTreeNode> m_Nodes, BinaryReader reader, ref int i)
		{
			var m_Node = m_Nodes[i];
			var varTypeStr = m_Node.Type;
			object value;
			var align = (m_Node.MetaFlag.IsAlignBytes());
			switch (varTypeStr)
			{
				case "SInt8":
					value = reader.ReadSByte();
					break;
				case "UInt8":
				case "char":
					value = reader.ReadByte();
					break;
				case "short":
				case "SInt16":
					value = reader.ReadInt16();
					break;
				case "UInt16":
				case "unsigned short":
					value = reader.ReadUInt16();
					break;
				case "int":
				case "SInt32":
					value = reader.ReadInt32();
					break;
				case "UInt32":
				case "unsigned int":
				case "Type*":
					value = reader.ReadUInt32();
					break;
				case "long long":
				case "SInt64":
					value = reader.ReadInt64();
					break;
				case "UInt64":
				case "unsigned long long":
				case "FileSize":
					value = reader.ReadUInt64();
					break;
				case "float":
					value = reader.ReadSingle();
					break;
				case "double":
					value = reader.ReadDouble();
					break;
				case "bool":
					value = reader.ReadBoolean();
					break;
				case "string":
					value = reader.ReadAlignedString();
					i += 3;
					break;
				case "map":
					{
						if (m_Nodes[i + 1].MetaFlag.IsAlignBytes())
							align = true;
						var map = GetNodes(m_Nodes, i);
						i += map.Count - 1;
						var first = GetNodes(map, 4);
						var next = 4 + first.Count;
						var second = GetNodes(map, next);
						var size = reader.ReadInt32();
						var dic = new List<KeyValuePair<object, object>>(size);
						for (int j = 0; j < size; j++)
						{
							int tmp1 = 0;
							int tmp2 = 0;
							dic.Add(new KeyValuePair<object, object>(ReadValue(first, reader, ref tmp1), ReadValue(second, reader, ref tmp2)));
						}
						value = dic;
						break;
					}
				case "TypelessData":
					{
						var size = reader.ReadInt32();
						value = reader.ReadBytes(size);
						i += 2;
						break;
					}
				default:
					{
						if (i < m_Nodes.Count - 1 && m_Nodes[i + 1].Type == "Array") //Array
						{
							if ((m_Nodes[i + 1].MetaFlag.IsAlignBytes()))
								align = true;
							var vector = GetNodes(m_Nodes, i);
							i += vector.Count - 1;
							var size = reader.ReadInt32();
							var list = new List<object>(size);
							for (int j = 0; j < size; j++)
							{
								int tmp = 3;
								list.Add(ReadValue(vector, reader, ref tmp));
							}
							value = list;
							break;
						}
						else //Clreplaced
						{
							var @clreplaced = GetNodes(m_Nodes, i);
							i += @clreplaced.Count - 1;
							var obj = new OrderedDictionary();
							for (int j = 1; j < @clreplaced.Count; j++)
							{
								var clreplacedmember = @clreplaced[j];
								var name = clreplacedmember.Name;
								obj[name] = ReadValue(@clreplaced, reader, ref j);
							}
							value = obj;
							break;
						}
					}
			}
			if (align)
				reader.AlignStream();
			return value;
		}

19 Source : LitePacketStream.cs
with MIT License
from Eastrall

private T ReadPrimitive<T>(Type type)
        {
            object primitiveValue = Type.GetTypeCode(type) switch
            {
                TypeCode.Byte => _reader.ReadByte(),
                TypeCode.SByte => _reader.ReadSByte(),
                TypeCode.Boolean => _reader.ReadBoolean(),
                TypeCode.Char => _reader.ReadChar(),
                TypeCode.Int16 => _reader.ReadInt16(),
                TypeCode.UInt16 => _reader.ReadUInt16(),
                TypeCode.Int32 => _reader.ReadInt32(),
                TypeCode.UInt32 => _reader.ReadUInt32(),
                TypeCode.Single => _reader.ReadSingle(),
                TypeCode.Double => _reader.ReadDouble(),
                TypeCode.Int64 => _reader.ReadInt64(),
                TypeCode.UInt64 => _reader.ReadUInt64(),
                TypeCode.String => InternalReadString(),
                _ => throw new NotImplementedException(),
            };

19 Source : SignedByteDataTypeHandler.cs
with MIT License
from elastacloud

protected override sbyte ReadSingle(BinaryReader reader, Thrift.SchemaElement tse, int length)
      {
         return reader.ReadSByte();
      }

19 Source : BsonReader.cs
with Apache License 2.0
from elastic

private BsonType ReadType()
		{
			MovePosition(1);
			return (BsonType)_reader.ReadSByte();
		}

19 Source : Wz_File.cs
with MIT License
from Elem8100

public int ReadInt32()
        {
            int s = this.BReader.ReadSByte();
            return (s == -128) ? this.BReader.ReadInt32() : s;
        }

19 Source : Wz_File.cs
with MIT License
from Elem8100

public long ReadInt64()
        {
            int s = this.BReader.ReadSByte();
            return (s == -128) ? this.BReader.ReadInt64() : s;
        }

19 Source : Wz_File.cs
with MIT License
from Elem8100

public float ReadSingle()
        {
            float fl = this.BReader.ReadSByte();
            return (fl == -128) ? this.BReader.ReadSingle() : fl;
        }

19 Source : Wz_File.cs
with MIT License
from Elem8100

public unsafe string ReadString()
        {
            int size = this.BReader.ReadSByte();
            string result = null;
            if (size < 0)
            {
                byte mask = 0xAA;
                size = (size == -128) ? this.BReader.ReadInt32() : -size;

                var buffer = GetStringBuffer(size);
                this.fileStream.Read(buffer, 0, size);
                this.WzStructure.encryption.keys.Decrypt(buffer, 0, size);

                fixed (byte* pData = buffer)
                {
                    for (int i = 0; i < size; i++)
                    {
                        pData[i] ^= mask;
                        unchecked { mask++; }
                    }

                    var enc = this.TextEncoding ?? Encoding.Default;
                    result = enc.GetString(buffer, 0, size);
                }
            }
            else if (size > 0)
            {
                ushort mask = 0xAAAA;
                if (size == 127)
                {
                    size = this.BReader.ReadInt32();
                }

                var buffer = GetStringBuffer(size * 2);
                this.fileStream.Read(buffer, 0, size * 2);
                this.WzStructure.encryption.keys.Decrypt(buffer, 0, size * 2);

                fixed (byte* pData = buffer)
                {
                    ushort* pChar = (ushort*)pData;
                    for (int i = 0; i < size; i++)
                    {
                        pChar[i] ^= mask;
                        unchecked { mask++; }
                    }

                    result = new string((char*)pChar, 0, size);
                }
            }
            else
            {
                return string.Empty;
            }

            //memory optimize
            if (result.Length <= 4)
            {
                for (int i = 0; i < result.Length; i++)
                {
                    if (result[i] >= 0x80)
                    {
                        return result;
                    }
                }
                return string.Intern(result);
            }
            else
            {
                return result;
            }
        }

19 Source : OleDocument.cs
with GNU General Public License v3.0
from ElevenPaths

private String GetValueType(Int64 Offset, Int32 Tipo)
        {
            try
            {
                this.stream.Seek(Offset, SeekOrigin.Begin);
                BinaryReader br = new BinaryReader(this.stream);
                switch (Tipo)
                {
                    case Body.Property.PROPERTY_TYPE_VT_VARIANT:
                        Tipo = br.ReadInt32();
                        return GetValueType(this.stream.Position, Tipo);
                    case Body.Property.PROPERTY_TYPE_VT_EMPTY:
                        return string.Empty;
                    case Body.Property.PROPERTY_TYPE_VT_NULL:
                        br.ReadByte();
                        return string.Empty;
                    case Body.Property.PROPERTY_TYPE_VT_I1:
                        return br.ReadSByte().ToString();
                    case Body.Property.PROPERTY_TYPE_VT_UI1:
                        return br.ReadByte().ToString();
                    case Body.Property.PROPERTY_TYPE_VT_I2:
                        return br.ReadInt16().ToString();
                    case Body.Property.PROPERTY_TYPE_VT_UI2:
                        return br.ReadUInt16().ToString();
                    case Body.Property.PROPERTY_TYPE_VT_I4:
                    case Body.Property.PROPERTY_TYPE_VT_INT:
                        return br.ReadInt32().ToString();
                    case Body.Property.PROPERTY_TYPE_VT_UI4:
                    case Body.Property.PROPERTY_TYPE_VT_UINT:
                        return br.ReadUInt32().ToString();
                    case Body.Property.PROPERTY_TYPE_VT_I8:
                        return br.ReadInt64().ToString();
                    case Body.Property.PROPERTY_TYPE_VT_UI8:
                        return br.ReadUInt64().ToString();
                    case Body.Property.PROPERTY_TYPE_VT_BOOL:
                        return br.ReadBoolean().ToString();
                    case Body.Property.PROPERTY_TYPE_VT_BSTR:
                        UInt32 SizeUnicode = br.ReadUInt32();
                        Byte[] BytesUnicode = br.ReadBytes((int)SizeUnicode);
                        return Encoding.Unicode.GetString(BytesUnicode, 0, (int)SizeUnicode);
                    case Body.Property.PROPERTY_TYPE_VT_LPSTR:
                        UInt32 Size = br.ReadUInt32();
                        if (Size > 0)
                            return Encoding.Default.GetString(br.ReadBytes((int)Size)).Replace('\0', ' ');
                        else
                            return string.Empty;
                    case Body.Property.PROPERTY_TYPE_VT_LPWSTR:
                        UInt32 SizeW = br.ReadUInt32();
                        if (SizeW > 0)
                            return Encoding.Unicode.GetString(br.ReadBytes((int)SizeW * 2)).Replace('\0', ' ');
                        else
                            return string.Empty;
                    case Body.Property.PROPERTY_TYPE_VT_FILETIME:
                        Int64 datetime = br.ReadInt64();
                        return datetime != 0 ? DateTime.FromFileTimeUtc(datetime).ToString() : string.Empty;
                    case Body.Property.PROPERTY_TYPE_VT_BLOB:
                        Size = br.ReadUInt32();
                        if (Size > 0 && Size < 128)
                        {
                            String s = Encoding.Default.GetString(br.ReadBytes((int)Size)).Replace('\0', ' ');

                            for (int i = 0; i < s.Length;)
                                if (char.IsControl(s[i])) s = s.Remove(i, 1);
                                else i++;
                            return s;
                        }
                        else
                            return string.Empty;
                    default:
                        return "Ole Property not supported: " + Tipo;
                }
            }
            catch
            {
                return string.Empty;
            }
        }

19 Source : TypeTreeHelper.cs
with MIT License
from evandixon

private static void ReadStringValue(StringBuilder sb, List<TypeTreeNode> members, BinaryReader reader, ref int i)
        {
            var member = members[i];
            var level = member.m_Level;
            var varTypeStr = member.m_Type;
            var varNameStr = member.m_Name;
            object value = null;
            var append = true;
            var align = (member.m_MetaFlag & 0x4000) != 0;
            switch (varTypeStr)
            {
                case "SInt8":
                    value = reader.ReadSByte();
                    break;
                case "UInt8":
                case "char":
                    value = reader.ReadByte();
                    break;
                case "short":
                case "SInt16":
                    value = reader.ReadInt16();
                    break;
                case "UInt16":
                case "unsigned short":
                    value = reader.ReadUInt16();
                    break;
                case "int":
                case "SInt32":
                    value = reader.ReadInt32();
                    break;
                case "UInt32":
                case "unsigned int":
                case "Type*":
                    value = reader.ReadUInt32();
                    break;
                case "long long":
                case "SInt64":
                    value = reader.ReadInt64();
                    break;
                case "UInt64":
                case "unsigned long long":
                case "FileSize":
                    value = reader.ReadUInt64();
                    break;
                case "float":
                    value = reader.ReadSingle();
                    break;
                case "double":
                    value = reader.ReadDouble();
                    break;
                case "bool":
                    value = reader.ReadBoolean();
                    break;
                case "string":
                    append = false;
                    var str = reader.ReadAlignedString();
                    sb.AppendFormat("{0}{1} {2} = \"{3}\"\r\n", (new string('\t', level)), varTypeStr, varNameStr, str);
                    i += 3;
                    break;
                case "map":
                    {
                        if ((members[i + 1].m_MetaFlag & 0x4000) != 0)
                            align = true;
                        append = false;
                        sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level)), varTypeStr, varNameStr);
                        sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level + 1)), "Array", "Array");
                        var size = reader.ReadInt32();
                        sb.AppendFormat("{0}{1} {2} = {3}\r\n", (new string('\t', level + 1)), "int", "size", size);
                        var map = GetMembers(members, i);
                        i += map.Count - 1;
                        var first = GetMembers(map, 4);
                        var next = 4 + first.Count;
                        var second = GetMembers(map, next);
                        for (int j = 0; j < size; j++)
                        {
                            sb.AppendFormat("{0}[{1}]\r\n", (new string('\t', level + 2)), j);
                            sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level + 2)), "pair", "data");
                            int tmp1 = 0;
                            int tmp2 = 0;
                            ReadStringValue(sb, first, reader, ref tmp1);
                            ReadStringValue(sb, second, reader, ref tmp2);
                        }
                        break;
                    }
                case "TypelessData":
                    {
                        append = false;
                        var size = reader.ReadInt32();
                        reader.ReadBytes(size);
                        i += 2;
                        sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level)), varTypeStr, varNameStr);
                        sb.AppendFormat("{0}{1} {2} = {3}\r\n", (new string('\t', level)), "int", "size", size);
                        break;
                    }
                default:
                    {
                        if (i < members.Count - 1 && members[i + 1].m_Type == "Array") //Array
                        {
                            if ((members[i + 1].m_MetaFlag & 0x4000) != 0)
                                align = true;
                            append = false;
                            sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level)), varTypeStr, varNameStr);
                            sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level + 1)), "Array", "Array");
                            var size = reader.ReadInt32();
                            sb.AppendFormat("{0}{1} {2} = {3}\r\n", (new string('\t', level + 1)), "int", "size", size);
                            var vector = GetMembers(members, i);
                            i += vector.Count - 1;
                            for (int j = 0; j < size; j++)
                            {
                                sb.AppendFormat("{0}[{1}]\r\n", (new string('\t', level + 2)), j);
                                int tmp = 3;
                                ReadStringValue(sb, vector, reader, ref tmp);
                            }
                            break;
                        }
                        else //Clreplaced
                        {
                            append = false;
                            sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level)), varTypeStr, varNameStr);
                            var @clreplaced = GetMembers(members, i);
                            i += @clreplaced.Count - 1;
                            for (int j = 1; j < @clreplaced.Count; j++)
                            {
                                ReadStringValue(sb, @clreplaced, reader, ref j);
                            }
                            break;
                        }
                    }
            }
            if (append)
                sb.AppendFormat("{0}{1} {2} = {3}\r\n", (new string('\t', level)), varTypeStr, varNameStr, value);
            if (align)
                reader.AlignStream();
        }

19 Source : TypeTreeHelper.cs
with MIT License
from evandixon

private static object ReadValue(List<TypeTreeNode> members, BinaryReader reader, ref int i)
        {
            var member = members[i];
            var varTypeStr = member.m_Type;
            object value;
            var align = (member.m_MetaFlag & 0x4000) != 0;
            switch (varTypeStr)
            {
                case "SInt8":
                    value = reader.ReadSByte();
                    break;
                case "UInt8":
                case "char":
                    value = reader.ReadByte();
                    break;
                case "short":
                case "SInt16":
                    value = reader.ReadInt16();
                    break;
                case "UInt16":
                case "unsigned short":
                    value = reader.ReadUInt16();
                    break;
                case "int":
                case "SInt32":
                    value = reader.ReadInt32();
                    break;
                case "UInt32":
                case "unsigned int":
                case "Type*":
                    value = reader.ReadUInt32();
                    break;
                case "long long":
                case "SInt64":
                    value = reader.ReadInt64();
                    break;
                case "UInt64":
                case "unsigned long long":
                case "FileSize":
                    value = reader.ReadUInt64();
                    break;
                case "float":
                    value = reader.ReadSingle();
                    break;
                case "double":
                    value = reader.ReadDouble();
                    break;
                case "bool":
                    value = reader.ReadBoolean();
                    break;
                case "string":
                    value = reader.ReadAlignedString();
                    i += 3;
                    break;
                case "map":
                    {
                        if ((members[i + 1].m_MetaFlag & 0x4000) != 0)
                            align = true;
                        var map = GetMembers(members, i);
                        i += map.Count - 1;
                        var first = GetMembers(map, 4);
                        var next = 4 + first.Count;
                        var second = GetMembers(map, next);
                        var size = reader.ReadInt32();
                        var dic = new List<KeyValuePair<object, object>>(size);
                        for (int j = 0; j < size; j++)
                        {
                            int tmp1 = 0;
                            int tmp2 = 0;
                            dic.Add(new KeyValuePair<object, object>(ReadValue(first, reader, ref tmp1), ReadValue(second, reader, ref tmp2)));
                        }
                        value = dic;
                        break;
                    }
                case "TypelessData":
                    {
                        var size = reader.ReadInt32();
                        value = reader.ReadBytes(size);
                        i += 2;
                        break;
                    }
                default:
                    {
                        if (i < members.Count - 1 && members[i + 1].m_Type == "Array") //Array
                        {
                            if ((members[i + 1].m_MetaFlag & 0x4000) != 0)
                                align = true;
                            var vector = GetMembers(members, i);
                            i += vector.Count - 1;
                            var size = reader.ReadInt32();
                            var list = new List<object>(size);
                            for (int j = 0; j < size; j++)
                            {
                                int tmp = 3;
                                list.Add(ReadValue(vector, reader, ref tmp));
                            }
                            value = list;
                            break;
                        }
                        else //Clreplaced
                        {
                            var @clreplaced = GetMembers(members, i);
                            i += @clreplaced.Count - 1;
                            var obj = new UType();
                            for (int j = 1; j < @clreplaced.Count; j++)
                            {
                                var clreplacedmember = @clreplaced[j];
                                var name = clreplacedmember.m_Name;
                                obj[name] = ReadValue(@clreplaced, reader, ref j);
                            }
                            value = obj;
                            break;
                        }
                    }
            }
            if (align)
                reader.AlignStream();
            return value;
        }

19 Source : BinaryReaderX.cs
with GNU General Public License v3.0
from FanTranslatorsInternational

public override sbyte ReadSByte()
        {
            Reset();

            return base.ReadSByte();
        }

19 Source : DRTest.cs
with MIT License
from FingerCaster

public override bool ParseDataRow(byte[] dataRowBytes, int startIndex, int length, object userData)
        {
            using (MemoryStream memoryStream = new MemoryStream(dataRowBytes, startIndex, length, false))
            {
                using (BinaryReader binaryReader = new BinaryReader(memoryStream, Encoding.UTF8))
                {
                    m_Id = binaryReader.Read7BitEncodedInt32();
                    BoolValue = binaryReader.ReadBoolean();
                    ByteValue = binaryReader.ReadByte();
                    CharValue = binaryReader.ReadChar();
                    Color32Value = binaryReader.ReadColor32();
                    ColorValue = binaryReader.ReadColor();
                    DateTimeValue = binaryReader.ReadDateTime();
                    DecimalValue = binaryReader.ReadDecimal();
                    DoubleValue = binaryReader.ReadDouble();
                    FloatValue = binaryReader.ReadSingle();
                    IntValue = binaryReader.Read7BitEncodedInt32();
                    LongValue = binaryReader.Read7BitEncodedInt64();
                    QuaternionValue = binaryReader.ReadQuaternion();
                    RectValue = binaryReader.ReadRect();
                    SByteValue = binaryReader.ReadSByte();
                    ShortValue = binaryReader.ReadInt16();
                    StringValue = binaryReader.ReadString();
                    UIntValue = binaryReader.Read7BitEncodedUInt32();
                    ULongValue = binaryReader.Read7BitEncodedUInt64();
                    UShortValue = binaryReader.ReadUInt16();
                    Vector2Value = binaryReader.ReadVector2();
                    Vector3Value = binaryReader.ReadVector3();
                    Vector4Value = binaryReader.ReadVector4();
					BoolList = binaryReader.ReadBooleanList();
					ByteList = binaryReader.ReadByteList();
					CharList = binaryReader.ReadCharList();
					Color32List = binaryReader.ReadColor32List();
					ColorList = binaryReader.ReadColorList();
					DateTimeList = binaryReader.ReadDateTimeList();
					DecimalList = binaryReader.ReadDecimalList();
					DoubleList = binaryReader.ReadDoubleList();
					FloatList = binaryReader.ReadSingleList();
					IntList = binaryReader.ReadInt32List();
					LongList = binaryReader.ReadInt64List();
					QuaternionList = binaryReader.ReadQuaternionList();
					RectList = binaryReader.ReadRectList();
					SByteList = binaryReader.ReadSByteList();
					ShortList = binaryReader.ReadInt16List();
					StringList = binaryReader.ReadStringList();
					UIntList = binaryReader.ReadUInt32List();
					ULongList = binaryReader.ReadUInt64List();
					UShortList = binaryReader.ReadUInt16List();
					Vector2List = binaryReader.ReadVector2List();
					Vector3List = binaryReader.ReadVector3List();
					Vector4List = binaryReader.ReadVector4List();
					BoolArray = binaryReader.ReadBooleanArray();
					ByteArray = binaryReader.ReadByteArray();
					CharArray = binaryReader.ReadCharArray();
					Color32Array = binaryReader.ReadColor32Array();
					ColorArray = binaryReader.ReadColorArray();
					DateTimeArray = binaryReader.ReadDateTimeArray();
					DecimalArray = binaryReader.ReadDecimalArray();
					DoubleArray = binaryReader.ReadDoubleArray();
					FloatArray = binaryReader.ReadSingleArray();
					IntArray = binaryReader.ReadInt32Array();
					LongArray = binaryReader.ReadInt64Array();
					QuaternionArray = binaryReader.ReadQuaternionArray();
					RectArray = binaryReader.ReadRectArray();
					SByteArray = binaryReader.ReadSByteArray();
					ShortArray = binaryReader.ReadInt16Array();
					StringArray = binaryReader.ReadStringArray();
					UIntArray = binaryReader.ReadUInt32Array();
					ULongArray = binaryReader.ReadUInt64Array();
					UShortArray = binaryReader.ReadUInt16Array();
					Vector2Array = binaryReader.ReadVector2Array();
					Vector3Array = binaryReader.ReadVector3Array();
					Vector4Array = binaryReader.ReadVector4Array();
                }
            }

            GeneratePropertyArray();
            return true;
        }

See More Examples