System.IO.BinaryReader.ReadString()

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

827 Examples 7

19 Source : Attributes.cs
with GNU Lesser General Public License v2.1
from BepInEx

void ICacheable.Load(BinaryReader br)
        {
            DependencyGUID = br.ReadString();
            Flags = (DependencyFlags)br.ReadInt32();

            var versionRange = br.ReadString();
            VersionRange = versionRange == string.Empty ? null : Range.Parse(versionRange);
        }

19 Source : PluginInfo.cs
with GNU Lesser General Public License v2.1
from BepInEx

void ICacheable.Load(BinaryReader br)
        {
            TypeName = br.ReadString();
            Location = br.ReadString();

            Metadata = new BepInPlugin(br.ReadString(), br.ReadString(), br.ReadString());

            var processListCount = br.ReadInt32();
            var processList = new List<BepInProcess>(processListCount);
            for (var i = 0; i < processListCount; i++)
                processList.Add(new BepInProcess(br.ReadString()));
            Processes = processList;

            var depCount = br.ReadInt32();
            var depList = new List<BepInDependency>(depCount);
            for (var i = 0; i < depCount; i++)
            {
                var dep = new BepInDependency("");
                ((ICacheable) dep).Load(br);
                depList.Add(dep);
            }

            Dependencies = depList;

            var incCount = br.ReadInt32();
            var incList = new List<BepInIncompatibility>(incCount);
            for (var i = 0; i < incCount; i++)
            {
                var inc = new BepInIncompatibility("");
                ((ICacheable) inc).Load(br);
                incList.Add(inc);
            }

            Incompatibilities = incList;

            TargettedBepInExVersion = new Version(br.ReadString());
        }

19 Source : PatcherPluginMetadata.cs
with GNU Lesser General Public License v2.1
from BepInEx

public void Load(BinaryReader br) => TypeName = br.ReadString();

19 Source : ShaderCompilationCache.cs
with Apache License 2.0
from bepu

public static bool TryLoad(Stream stream, out ShaderCompilationCache cache)
        {
            using (var reader = new BinaryReader(stream))
            {
                try
                {
                    cache = new ShaderCompilationCache((ShaderFlags)reader.ReadInt32());

                    byte[] data = new byte[16384];

                    var shaderDataCount = reader.ReadInt32();
                    for (int i = 0; i < shaderDataCount; ++i)
                    {
                        var shaderSource = SourceShader.Read(reader);

                        //Read the size in bytes of the content element data itself.
                        int sizeInBytes = reader.ReadInt32();

                        if (data.Length < sizeInBytes)
                            data = new byte[sizeInBytes];

                        reader.Read(data, 0, sizeInBytes);

                        ShaderBytecode bytecode;
                        unsafe
                        {
                            fixed (byte* buffer = data)
                            {
                                bytecode = new ShaderBytecode(new IntPtr(buffer), sizeInBytes);
                            }
                        }
                        cache.CompiledShaders.Add(shaderSource, bytecode);
                    }

                    var timeStampCount = reader.ReadInt32();
                    for (int i = 0; i < timeStampCount; ++i)
                    {
                        var shaderSource = reader.ReadString();

                        //Read the time stamp.
                        long timeStamp = reader.ReadInt64();
                        cache.TimeStamps.Add(shaderSource, timeStamp);
                    }

                    var dependenciesCount = reader.ReadInt32();
                    for (int i = 0; i < dependenciesCount; ++i)
                    {
                        var shaderSource = reader.ReadString();
                        var pathDependenciesCount = reader.ReadInt32();
                        var dependencies = new HashSet<string>();
                        for (int j = 0; j < pathDependenciesCount; ++j)
                        {
                            dependencies.Add(reader.ReadString());
                        }
                        cache.Dependencies.Add(shaderSource, dependencies);
                    }
                }
                catch
                {
                    cache = null;
                    return false;
                }
                return true;
            }
        }

19 Source : FontIO.cs
with Apache License 2.0
from bepu

public static FontContent Load(BinaryReader reader)
        {
            var name = reader.ReadString();
            var inverseSizeInTexels = reader.ReadSingle();
            var glyphCount = reader.ReadInt32();
            var characterData = new Dictionary<char, CharacterData>();
            for (int i = 0; i < glyphCount; ++i)
            {
                var character = reader.ReadChar();
                CharacterData data;
                data.SourceMinimum.X = reader.ReadInt32();
                data.SourceMinimum.Y = reader.ReadInt32();
                data.SourceSpan.X = reader.ReadInt32();
                data.SourceSpan.Y = reader.ReadInt32();
                data.Bearing.X = reader.ReadInt32();
                data.Bearing.Y = reader.ReadInt32();
                data.Advance = reader.ReadInt32();
                data.DistanceScale = reader.ReadSingle();
                characterData.Add(character, data);
            }
            var kerningRelationshipCount = reader.ReadInt32();
            var kerningTable = new Dictionary<CharacterPair, int>();
            for (int i = 0; i < kerningRelationshipCount; ++i)
            {
                var a = reader.ReadChar();
                var b = reader.ReadChar();
                var amount = reader.ReadInt32();
                kerningTable.Add(new CharacterPair(a, b), amount);
            }
            var atlas = Texture2DIO.Load(reader);
            return new FontContent(atlas, name, inverseSizeInTexels, characterData, kerningTable);
        }

19 Source : GLSLIO.cs
with Apache License 2.0
from bepu

public static GLSLContent Load(BinaryReader reader) =>
            new GLSLContent(reader.ReadString());

19 Source : SourceShader.cs
with Apache License 2.0
from bepu

public static SourceShader Read(BinaryReader reader)
        {
            var name = reader.ReadString();
            var defineCount = reader.ReadInt32();
            var defines = new string[defineCount];
            for (int i = 0; i < defineCount; ++i)
            {
                defines[i] = reader.ReadString();
            }
            return new SourceShader { Name = name, Defines = defines };
        }

19 Source : ContentBuildCacheIO.cs
with Apache License 2.0
from bepu

public static Dictionary<string, ContentElement> Load(Stream stream)
        {
            using (var reader = new BinaryReader(stream))
            {
                try
                {
                    var cache = new Dictionary<string, ContentElement>();
                    var contentCount = reader.ReadInt32();

                    for (int i = 0; i < contentCount; ++i)
                    {
                        var path = reader.ReadString();
                        var lastModifiedTimestamp = reader.ReadInt64();
                        var contentType = (ContentType)reader.ReadInt32();
                        var content = ContentArchive.Load(contentType, reader);
                        cache.Add(path, new ContentElement { LastModifiedTimestamp = lastModifiedTimestamp, Content = content });
                    }
                    return cache;
                }
                catch (Exception e)
                {
                    Console.WriteLine($"Content build cache load failed; may be corrupted. replaceduming fresh build. Message:");
                    Console.WriteLine(e.Message);
                    return new Dictionary<string, ContentElement>();
                }
            }
        }

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

public override string ReadString() => base.ReadString();

19 Source : Models.cs
with MIT License
from BlazorPlus

static internal CommandMessage UnpackRest(MemoryStream ms)
		{
			CommandMessage msg = new CommandMessage();

			BinaryReader br = new BinaryReader(ms); //TODO:performance dont use BinaryWriter/BinaryReader
			string flag = br.ReadString();
			if (flag[0] == '1')
				msg.Name = br.ReadString();
			if (flag[1] == '1')
			{
				msg.Data = br.ReadBytes(br.ReadInt32());//TODO:..better implementation for Memory<byte>
			}
			if (flag[2] == '1')
			{
				string parts = br.ReadString();
				if (parts == "")
				{
					msg.Args = Array.Empty<string>();
				}
				else
				{
					msg.Args = parts.Split(',');
					for (int i = 0; i < msg.Args.Length; i++)
					{
						msg.Args[i] = msg.Args[i] == "-" ? null : br.ReadString();
						//if (msg.Args[i] == END_H8) throw new Exception("unexpected " + END_H8 + " parts:" + parts);
					}
				}
			}

			string endstr = br.ReadString();
			if (endstr != END_H8)
				throw new Exception("Invalid footer : " + endstr);

			return msg;
		}

19 Source : StorageManager.cs
with zlib License
from blendogames

public HighScoreEntry LoadHighScores()
        {
            HighScoreEntry data = new HighScoreEntry();

            if (highScoreDevice == null)
            {
                return data;
            }

            bool createFile = false;

            try
            {
                using (StorageContainer container = highScoreDevice.OpenContainer(GAMENAME))
                {
                    using (Stream stream = container.OpenFile(SCOREFILE, FileMode.OpenOrCreate, FileAccess.Read))
                    {
                        // Read the data from the file
                        BinaryReader reader = new BinaryReader(stream);

                        try
                        {
                            data.count = reader.ReadInt16();
                            for (int i = 0; i < data.count; i++)
                            {
                                data.commanderName[i] = reader.ReadString();
                                data.scores[i] = reader.ReadInt32();
                            }
                        }
                        catch //(Exception ex)
                        {
                            //something went caca, so load default data.
                            //Console.WriteLine(ex);
                            createFile = true;
                        }

                        reader.Close();
                    }

                    container.Dispose();
                }
            }
            catch
            {
            }

            if (createFile)
            {
                //If the file doesn't exist, make a new one.
                data = new HighScoreEntry();
                SaveHighScores(data);
            }

            return data;
        }

19 Source : Message.cs
with GNU General Public License v3.0
from bonarr

public static Message ReadFrom(Stream stream)
        {
            var message = new Message();
            var binaryReader = new BinaryReader(stream);
            message.Source = binaryReader.ReadString();
            message.Key = binaryReader.ReadString();
            int bytes = binaryReader.ReadInt32();
            message.Value = new ArraySegment<byte>(binaryReader.ReadBytes(bytes));
            message.CommandId = binaryReader.ReadString();
            message.WaitForAck = binaryReader.ReadBoolean();
            message.IsAck = binaryReader.ReadBoolean();
            message.Filter = binaryReader.ReadString();

            return message;
        }

19 Source : ByteAccess.cs
with GNU General Public License v3.0
from byt3m

public string ReadString()
        {
            return reader.ReadString();
        }

19 Source : CakeScriptSerializer.cs
with MIT License
from cake-build

public static CakeScript Deserialize(BinaryReader reader)
        {
            if (reader == null)
            {
                throw new ArgumentNullException(nameof(reader));
            }

            // TypeId and Version
            var typeAndVersion = reader.ReadInt16();
            if (typeAndVersion != Constants.CakeScript.TypeAndVersion)
            {
                throw new InvalidOperationException($"Unsupported type or version: {typeAndVersion}");
            }

            var cakeScript = new CakeScript();

            // Host object
            cakeScript.Host.TypeName = reader.ReadString();
            cakeScript.Host.replacedemblyPath = reader.ReadString();

            // Source
            var bytesLength = reader.ReadInt32();
            var bytes = reader.ReadBytes(bytesLength);
            cakeScript.Source = Unzip(bytes);

            // References
            var referencesLength = reader.ReadInt32();
            for (var i = 0; i < referencesLength; i++)
            {
                cakeScript.References.Add(reader.ReadString());
            }

            // Usings
            var usingsLength = reader.ReadInt32();
            for (var i = 0; i < usingsLength; i++)
            {
                cakeScript.Usings.Add(reader.ReadString());
            }

            return cakeScript;
        }

19 Source : FileChangeSerializer.cs
with MIT License
from cake-build

public static FileChange Deserialize(BinaryReader reader, out byte version)
        {
            if (reader == null)
            {
                throw new ArgumentNullException(nameof(reader));
            }

            // TypeId and Version
            var typeAndVersion = reader.ReadInt16();
            version = (byte)(typeAndVersion & 0x00FF);
            if (typeAndVersion != Constants.FileChange.TypeAndVersion)
            {
                var type = (byte)((typeAndVersion & 0xFF00) >> 8);
                if (type != Constants.FileChange.TypeId)
                {
                    throw new InvalidOperationException($"Unsupported type: {type}");
                }
                if (version > Constants.Protocol.Latest)
                {
                    throw new InvalidOperationException($"Unsupported version: {version}");
                }
            }

            var fileChange = new FileChange();

            // From disk
            fileChange.FromDisk = reader.ReadBoolean();

            // Buffer
            fileChange.Buffer = reader.ReadString();

            // Filename
            fileChange.FileName = reader.ReadString();

            // LineChanges
            var lineChanges = reader.ReadInt32();
            for (var i = 0; i < lineChanges; i++)
            {
                var lineChange = new LineChange();
                lineChange.StartLine = reader.ReadInt32();
                lineChange.EndLine = reader.ReadInt32();
                lineChange.StartColumn = reader.ReadInt32();
                lineChange.EndColumn = reader.ReadInt32();
                lineChange.NewText = reader.ReadString();
                fileChange.LineChanges.Add(lineChange);
            }

            return fileChange;
        }

19 Source : SilverlightSerializer.cs
with MIT License
from CalciumFramework

public static object Deserialize(Stream inputStream, object instance = null)
		{
			var v = Verbose;
			CreateStacks();
			try
			{
				_ktStack.Push(_knownTypes);
				_piStack.Push(_propertyIds);
				_loStack.Push(_loadedObjects);

				var rw = new BinaryReader(inputStream);
				var version = rw.ReadString();
				var count = rw.ReadInt32();
				if (version == "SerV3")
					Verbose = rw.ReadBoolean();
				_propertyIds = new List<string>();
				_knownTypes = new List<Type>();
				_loadedObjects = new List<object>();
				for (var i = 0; i < count; i++)
				{
					var typeName = rw.ReadString();
					
					var tp = Type.GetType(typeName);
					if (tp == null)
					{
						typeName = typeName.Replace(", System.Private.CoreLib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e", string.Empty);
						tp = Type.GetType(typeName);
						if (tp == null)
						{
							var map = new TypeMappingEventArgs
							{
								TypeName = typeName
							};
							InvokeMapMissingType(map);
							tp = map.UseType;
						}
					}
					if (!Verbose)
					{
						if (tp == null)
						{
							throw new ArgumentException(string.Format("SilverlightSerializer: Cannot reference type {0} in this context", typeName));
						}
					}
					_knownTypes.Add(tp);
				}
				count = rw.ReadInt32();
				for (var i = 0; i < count; i++)
				{
					_propertyIds.Add(rw.ReadString());
				}

				return DeserializeObject(rw, null, instance);
			}
			finally
			{
				_knownTypes = _ktStack.Pop();
				_propertyIds = _piStack.Pop();
				_loadedObjects = _loStack.Pop();
				Verbose = v;
			}
		}

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 : DebuggerServer.cs
with MIT License
from CatLib

void OnReceive(DebugMessageType type, byte[] buffer)
        {
            if (clientSocket == null || clientSocket.Disconnected)
                return;
            System.IO.MemoryStream ms = new System.IO.MemoryStream(buffer);
            System.IO.BinaryReader br = new System.IO.BinaryReader(ms);

            switch (type)
            {
                case DebugMessageType.CSAttach:
                    {
                        SendAttachResult();
                    }
                    break;
                case DebugMessageType.CSBindBreakpoint:
                    {
                        CSBindBreakpoint msg = new Protocol.CSBindBreakpoint();
                        msg.BreakpointHashCode = br.ReadInt32();
                        msg.IsLambda = br.ReadBoolean();
                        msg.TypeName = br.ReadString();
                        msg.MethodName = br.ReadString();
                        msg.StartLine = br.ReadInt32();
                        msg.EndLine = br.ReadInt32();
                        TryBindBreakpoint(msg);
                    }
                    break;
                case DebugMessageType.CSDeleteBreakpoint:
                    {
                        CSDeleteBreakpoint msg = new Protocol.CSDeleteBreakpoint();
                        msg.BreakpointHashCode = br.ReadInt32();
                        ds.DeleteBreakpoint(msg.BreakpointHashCode);
                    }
                    break;
                case DebugMessageType.CSExecute:
                    {
                        CSExecute msg = new Protocol.CSExecute();
                        msg.ThreadHashCode = br.ReadInt32();
                        ds.ExecuteThread(msg.ThreadHashCode);
                    }
                    break;
                case DebugMessageType.CSStep:
                    {
                        CSStep msg = new CSStep();
                        msg.ThreadHashCode = br.ReadInt32();
                        msg.StepType = (StepTypes)br.ReadByte();
                        ds.StepThread(msg.ThreadHashCode, msg.StepType);
                    }
                    break;
                case DebugMessageType.CSResolveVariable:
                    {
                        CSResolveVariable msg = new CSResolveVariable();
                        msg.ThreadHashCode = br.ReadInt32();
                        msg.Variable = ReadVariableReference(br);
                        VariableInfo info;
                        try
                        {
                            object res;
                            info = ds.ResolveVariable(msg.ThreadHashCode, msg.Variable, out res);
                        }
                        catch (Exception ex)
                        {
                            info = VariableInfo.GetException(ex);
                        }
                        if (info.Type != VariableTypes.Pending)
                            SendSCResolveVariableResult(info);
                    }
                    break;
                case DebugMessageType.CSResolveIndexAccess:
                    {
                        CSResolveIndexer msg = new CSResolveIndexer();
                        msg.ThreadHashCode = br.ReadInt32();
                        msg.Body = ReadVariableReference(br);
                        msg.Index = ReadVariableReference(br);

                        VariableInfo info;
                        try
                        {
                            object res;
                            info = ds.ResolveIndexAccess(msg.ThreadHashCode, msg.Body, msg.Index, out res);
                        }
                        catch(Exception ex)
                        {
                            info = VariableInfo.GetException(ex);
                        }
                        if (info.Type != VariableTypes.Pending)
                            SendSCResolveVariableResult(info);
                    }
                    break;
                case DebugMessageType.CSEnumChildren:
                    {
                        int thId = br.ReadInt32();
                        var parent = ReadVariableReference(br);

                        VariableInfo[] info = null;
                        try
                        {
                            info = ds.EnumChildren(thId, parent);
                        }
                        catch(Exception ex)
                        {
                            info = new VariableInfo[] { VariableInfo.GetException(ex) };
                        }
                        if (info != null)
                            SendSCEnumChildrenResult(info);
                    }
                    break;
            }

        }

19 Source : DebuggerServer.cs
with MIT License
from CatLib

VariableReference ReadVariableReference(System.IO.BinaryReader br)
        {
            VariableReference res = null;
            if (br.ReadBoolean())
            {
                res = new Debugger.VariableReference();
                res.Address = br.ReadInt64();
                res.Type = (VariableTypes)br.ReadByte();
                res.Offset = br.ReadInt32();
                res.Name = br.ReadString();
                res.Parent = ReadVariableReference(br);
                int cnt = br.ReadInt32();
                res.Parameters = new VariableReference[cnt];
                for(int i = 0; i < cnt; i++)
                {
                    res.Parameters[i] = ReadVariableReference(br);
                }
            }
            return res;
        }

19 Source : Pipe.cs
with GNU Affero General Public License v3.0
from cc004

private void Listen()
        {
            while (true)
            {
                try
                {
                    client = new TcpClient();
                    client.Connect(ep);
                    reader = new BinaryReader(client.GetStream());
                    writer = new BinaryWriter(client.GetStream());
                    for (; ; )
                    {
                        var s = reader.ReadString();
                        if (!string.IsNullOrEmpty(s))
                        {
                            history.Enqueue(s);
                            if (history.Count > 1000) history.Dequeue();
                            Input?.Invoke(s);
                        }
                    }
                }
                catch
                {

                }
            }
        }

19 Source : Program.cs
with GNU General Public License v3.0
from chi-rei-den

private static void Main(string[] args)
        {
            var FILE_PATH = Environment.ExpandEnvironmentVariables(@"%USERPROFILE%\Doreplacedents\My Games\Terraria\ModLoader\Mods\Localizer.tmod");
            var tModLoaderVersion = "";
            var modName = "";
            var modVersion = "";
            var files = new List<(string fileName, int length, int compressedLength, byte[] content)>();

            using (var fileStream = File.OpenRead(FILE_PATH))
            {
                using (var br = new BinaryReader(fileStream))
                {
                    br.ReadBytes(4); // TMOD
                    tModLoaderVersion = br.ReadString(); // tModLoader version
                    br.ReadBytes(280); // Signature
                    modName = br.ReadString(); // Name
                    modVersion = br.ReadString(); // Version
                    var fileCount = br.ReadInt32();
                    for (var i = 0; i < fileCount; i++)
                    {
                        var entry = (filename: br.ReadString(), length: br.ReadInt32(),
                                     compressedLength: br.ReadInt32(),
                                     content: new byte[] { });
                        files.Add(entry);
                    }

                    for (var i = 0; i < fileCount; i++)
                    {
                        var file = files[i];
                        var content = br.ReadBytes(file.compressedLength);
                        files[i] = (file.fileName, file.length, file.compressedLength, content);
                    }
                }
            }

            if (!modName.StartsWith("!"))
            {
                modName = "!" + modName;
            }

            files = files.Select(f => (f.fileName.EndsWith("NA.dll") && !f.fileName.StartsWith("!"))
                                     ? ("!" + f.fileName, f.length, f.compressedLength, f.content)
                                     : f).ToList();

            using (var fileStream = new FileStream(FILE_PATH, FileMode.Create, FileAccess.ReadWrite))
            {
                using (var bw = new BinaryWriter(fileStream))
                {
                    bw.Write(Encoding.UTF8.GetBytes("TMOD"));
                    bw.Write(tModLoaderVersion);
                    var hashPos = bw.BaseStream.Position;
                    bw.Seek(280, SeekOrigin.Current);
                    var contentPos = bw.BaseStream.Position;
                    bw.Write(modName);
                    bw.Write(modVersion);
                    bw.Write(files.Count);
                    foreach (var file in files)
                    {
                        bw.Write(file.fileName);
                        bw.Write(file.length);
                        bw.Write(file.compressedLength);
                    }
                    foreach (var file in files)
                    {
                        bw.Write(file.content);
                    }
                    bw.Seek((int)contentPos, SeekOrigin.Begin);
                    var hash = SHA1.Create().ComputeHash(bw.BaseStream);
                    bw.Seek((int)hashPos, SeekOrigin.Begin);
                    bw.Write(hash);
                }
            }

            var enabledFilePath =
                Environment.ExpandEnvironmentVariables(
                    @"%USERPROFILE%\Doreplacedents\My Games\Terraria\ModLoader\Mods\enabled.json");

            if (!File.Exists(enabledFilePath))
            {
                return;
            }

            File.WriteAllText(enabledFilePath, File.ReadAllText(enabledFilePath).Replace("\"Localizer\"", "\"!Localizer\""));
        }

19 Source : App.xaml.cs
with MIT License
from ChromaControl

[System.Diagnostics.Codereplacedysis.SuppressMessage("CodeQuality", "IDE0051:Remove unused private members", Justification = "Only used in release configuration")]
        private Guid GetSecureGuid(string name)
        {
            var storageFile = StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///Data/ChromaControl.dat")).AsTask().GetAwaiter().GetResult();

            var guids = new Dictionary<string, Guid>();

            using (var fileStream = storageFile.OpenStreamForReadAsync().GetAwaiter().GetResult())
            {
                using (var aes = Aes.Create())
                {
                    var key = new byte[32];
                    var iv = new byte[16];

                    fileStream.Read(key, 0, key.Length);
                    fileStream.Read(iv, 0, iv.Length);

                    using (var cryptoStream = new CryptoStream(fileStream, aes.CreateDecryptor(key, iv), CryptoStreamMode.Read))
                    {
                        using (var binReader = new BinaryReader(cryptoStream))
                        {
                            var count = binReader.ReadInt32();

                            for (var i = 0; i < count; i++)
                                guids.Add(binReader.ReadString(), Guid.Parse(binReader.ReadString()));
                        }
                    }
                }
            }

            return guids[name];
        }

19 Source : UsbDevices.cs
with MIT License
from Const-me

static string findDeviceName( Stream resource, int blobOffset, ushort deviceId )
		{
			resource.Seek( payloadOffset.Value + blobOffset, SeekOrigin.Begin );
			using( var unzip = new GZipStream( resource, CompressionMode.Decompress ) )
			using( var reader = new BinaryReader( unzip ) )
			{
				int count = reader.ReadUInt16();
				for( int i = 0; i < count; i++ )
				{
					ushort dev = reader.ReadUInt16();
					if( dev == deviceId )
						return reader.ReadString();
					if( dev > deviceId )
					{
						// Keys in the blob are sorted. If what we have read is greater than what we look for, it means the data won't be found.
						return null;
					}
					reader.ReadString();
				}
				return null;
			}
		}

19 Source : UsbVendors.cs
with MIT License
from Const-me

static string findVendorName( ushort vendor )
		{
			var replaced = replacedembly.GetExecutingreplacedembly();
			using( var stm = replaced.GetManifestResourceStream( "Vrmac.Input.Linux.usb-vendors.gz" ) )
			using( var unzip = new GZipStream( stm, CompressionMode.Decompress ) )
			using( var reader = new BinaryReader( unzip ) )
			{
				int size = reader.ReadUInt16();
				for( int i = 0; i < size; i++ )
				{
					ushort key = reader.ReadUInt16();
					if( key == vendor )
						return reader.ReadString();
					if( key > vendor )
						return null;
					reader.ReadString();
				}
				return null;
			}
		}

19 Source : Configuration.Deserialization.cs
with MIT License
from CragonGame

private static Configuration DeserializeBinary(BinaryReader reader, Stream stream)
        {
            if (stream == null)
                throw new ArgumentNullException("stream");

            bool ownReader = false;

            if (reader == null)
            {
                reader = new BinaryReader(stream);
                ownReader = true;
            }

            try
            {
                var config = new Configuration();

                int sectionCount = reader.ReadInt32();

                for (int i = 0; i < sectionCount; ++i)
                {
                    string sectionName = reader.ReadString();
                    int settingCount = reader.ReadInt32();

                    Section section = new Section(sectionName);

                    DeserializeComments(reader, section);

                    for (int j = 0; j < settingCount; j++)
                    {
                        Setting setting = new Setting(
                            reader.ReadString(),
                            reader.ReadString());

                        DeserializeComments(reader, setting);

                        section.Add(setting);
                    }

                    config.Add(section);
                }

                return config;
            }
            finally
            {
                if (ownReader)
                    reader.Close();
            }
        }

19 Source : Configuration.Deserialization.cs
with MIT License
from CragonGame

private static void DeserializeComments(BinaryReader reader, ConfigurationElement element)
        {
            bool hasComment = reader.ReadBoolean();
            if (hasComment)
            {
                char symbol = reader.ReadChar();
                string commentValue = reader.ReadString();
                element.Comment = new Comment(commentValue, symbol);
            }

            int preCommentCount = reader.ReadInt32();

            if (preCommentCount > 0)
            {
                element.mPreComments = new List<Comment>(preCommentCount);

                for (int i = 0; i < preCommentCount; ++i)
                {
                    char symbol = reader.ReadChar();
                    string commentValue = reader.ReadString();
                    element.mPreComments.Add(new Comment(commentValue, symbol));
                }
            }
        }

19 Source : SimpleJSONBinary.cs
with MIT License
from cre8ivepark

public static JSONNode DeserializeBinary(System.IO.BinaryReader aReader)
        {
            JSONNodeType type = (JSONNodeType)aReader.ReadByte();
            switch (type)
            {
                case JSONNodeType.Array:
                    {
                        int count = aReader.ReadInt32();
                        JSONArray tmp = new JSONArray();
                        for (int i = 0; i < count; i++)
                            tmp.Add(DeserializeBinary(aReader));
                        return tmp;
                    }
                case JSONNodeType.Object:
                    {
                        int count = aReader.ReadInt32();
                        JSONObject tmp = new JSONObject();
                        for (int i = 0; i < count; i++)
                        {
                            string key = aReader.ReadString();
                            var val = DeserializeBinary(aReader);
                            tmp.Add(key, val);
                        }
                        return tmp;
                    }
                case JSONNodeType.String:
                    {
                        return new JSONString(aReader.ReadString());
                    }
                case JSONNodeType.Number:
                    {
                        return new JSONNumber(aReader.ReadDouble());
                    }
                case JSONNodeType.Boolean:
                    {
                        return new JSONBool(aReader.ReadBoolean());
                    }
                case JSONNodeType.NullValue:
                    {
                        return JSONNull.CreateOrGet();
                    }
                default:
                    {
                        throw new Exception("Error deserializing JSON. Unknown tag: " + type);
                    }
            }
        }

19 Source : Pablo.cs
with MIT License
from cwensley

public override void Load (Stream fs, CharacterDoreplacedent doreplacedent, CharacterHandler handler)
		{
			var page = doreplacedent.Pages [0];
			
			

			var br = new BinaryReader(fs);
			var fontID = br.ReadString ();
			if (string.IsNullOrEmpty(fontID))
				page.Font = new BitFont(fs, BitFont.StandardCodePage);
			else {
				page.Font = doreplacedent.Info.GetFonts ().SelectMany(r => r.Fonts).FirstOrDefault (r => r.ID == fontID);
			}
			var palSize = br.ReadInt16 ();
			var canvas = page.Canvas;
			
			var pal = page.Palette;
			pal.Load (br, palSize, 0);
			
			ResizeCanvasWidth (fs, doreplacedent, canvas);
			
			var p = Load (fs, canvas, pal);
			
			ResizeCanvasHeight (doreplacedent, canvas, p.Y + 1);
		}

19 Source : SerializableReaderWriter.cs
with MIT License
from CyAScott

public static async Task<object> ReadSerializable(this BinaryReader reader, IResolveProxyIds resolver, Type type = null)
        {
            type = type ?? reader.ReadType();

            var useCustomSerializer = reader.ReadBoolean();

            if (useCustomSerializer)
            {
                var context = new StreamingContext(StreamingContextStates.All, resolver);
                var info = new SerializationInfo(type, new DefaultFormatterConverter());
                var length = reader.ReadInt32();

                for (var index = 0; index < length; index++)
                {
                    var itemName = reader.ReadString();
                    var itemType = reader.ReadType();
                    var item = await reader.ReadObject(resolver).ConfigureAwait(false);

                    info.AddValue(itemName, item, itemType);
                }

                var ctor = type.getCtor();

                return ctor.Invoke(new object[]
                {
                    info, context
                });
            }

            var returnValue = FormatterServices.GetUninitializedObject(type);

            foreach (var field in type.getFields())
            {
                field.SetValue(returnValue, await reader.ReadObject(resolver).ConfigureAwait(false));
            }

            return returnValue;
        }

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 : TypeReaderWriter.cs
with MIT License
from CyAScott

public static Type ReadType(this BinaryReader reader)
        {
            var shortType = (ShortTypes)reader.ReadByte();
            return shortType == ShortTypes.Unknown ? Type.GetType(reader.ReadString(), true) : map.First(item => item.Value == shortType).Key;
        }

19 Source : SimpleJSON.cs
with MIT License
from CymaticLabs

public static JSONNode Deserialize(System.IO.BinaryReader aReader)
        {
            JSONNodeType type = (JSONNodeType)aReader.ReadByte();
            switch (type)
            {
                case JSONNodeType.Array:
                    {
                        int count = aReader.ReadInt32();
                        JSONArray tmp = new JSONArray();
                        for (int i = 0; i < count; i++)
                            tmp.Add(Deserialize(aReader));
                        return tmp;
                    }
                case JSONNodeType.Object:
                    {
                        int count = aReader.ReadInt32();
                        JSONObject tmp = new JSONObject();
                        for (int i = 0; i < count; i++)
                        {
                            string key = aReader.ReadString();
                            var val = Deserialize(aReader);
                            tmp.Add(key, val);
                        }
                        return tmp;
                    }
                case JSONNodeType.String:
                    {
                        return new JSONString(aReader.ReadString());
                    }
                case JSONNodeType.Number:
                    {
                        return new JSONNumber(aReader.ReadDouble());
                    }
                case JSONNodeType.Boolean:
                    {
                        return new JSONBool(aReader.ReadBoolean());
                    }
                case JSONNodeType.NullValue:
                    {
                        return new JSONNull();
                    }
                default:
                    {
                        throw new Exception("Error deserializing JSON. Unknown tag: " + type);
                    }
            }
        }

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

public static bool ReadFromFile(BinaryReader reader, out ModelSpawn spawn)
        {
            spawn = new ModelSpawn();

            spawn.flags = reader.ReadByte();
            spawn.adtId = reader.ReadByte();
            spawn.Id = reader.ReadUInt32();
            spawn.iPos = reader.Read<Vector3>();
            spawn.iRot = reader.Read<Vector3>();
            spawn.iScale = reader.ReadSingle();

            bool has_bound = Convert.ToBoolean(spawn.flags & (uint)ModelFlags.HasBound);
            if (has_bound) // only WMOs have bound in MPQ, only available after computation
            {
                Vector3 bLow = reader.Read<Vector3>();
                Vector3 bHigh = reader.Read<Vector3>();
                spawn.iBound = new AxisAlignedBox(bLow, bHigh);
            }

            uint nameLen = reader.ReadUInt32();
            spawn.name = reader.ReadString((int)nameLen);
            return true;
        }

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

public static bool ReadFromFile(BinaryReader reader, out ModelSpawn spawn)
        {
            spawn = new ModelSpawn();
            spawn.flags = reader.ReadUInt32();
            spawn.adtId = reader.ReadUInt16();
            spawn.ID = reader.ReadUInt32();
            spawn.iPos = reader.ReadVector3();
            spawn.iRot = reader.ReadVector3();
            spawn.iScale = reader.ReadSingle();

            if ((spawn.flags & ModelFlags.HasBound) != 0) // only WMOs have bound in MPQ, only available after computation
            {
                Vector3 bLow = reader.ReadVector3();
                Vector3 bHigh = reader.ReadVector3();
                spawn.iBound = new AxisAlignedBox(bLow, bHigh);
            }

            int nameLen = reader.ReadInt32();
            spawn.name = reader.ReadString(nameLen);
            return true;
        }

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

public bool Open(uint fileId, WMORoot rootWmo)
        {
            Stream stream = Program.CascHandler.OpenFile((int)fileId);
            if (stream == null)
            {
                Console.WriteLine("No such file.");
                return false;
            }

            using (BinaryReader reader = new(stream))
            {
                long fileLength = reader.BaseStream.Length;
                while (reader.BaseStream.Position < fileLength)
                {
                    string fourcc = reader.ReadStringFromChars(4, true);
                    uint size = reader.ReadUInt32();

                    if (fourcc == "MOGP")//Fix sizeoff = Data size.
                        size = 68;

                    long nextpos = reader.BaseStream.Position + size;

                    if (fourcc == "MOGP")//header
                    {
                        groupName = reader.ReadInt32();
                        descGroupName = reader.ReadInt32();
                        mogpFlags = reader.ReadInt32();

                        for (var i = 0; i < 3; ++i)
                            bbcorn1[i] = reader.ReadSingle();

                        for (var i = 0; i < 3; ++i)
                            bbcorn2[i] = reader.ReadSingle();

                        moprIdx = reader.ReadUInt16();
                        moprNItems = reader.ReadUInt16();
                        nBatchA = reader.ReadUInt16();
                        nBatchB = reader.ReadUInt16();
                        nBatchC = reader.ReadUInt32();
                        fogIdx = reader.ReadUInt32();
                        groupLiquid = reader.ReadUInt32();
                        groupWMOID = reader.ReadUInt32();

                        // according to WoW.Dev Wiki:
                        if (Convert.ToBoolean(rootWmo.flags & 4))
                            groupLiquid = GetLiquidTypeId(groupLiquid);
                        else if (groupLiquid == 15)
                            groupLiquid = 0;
                        else
                            groupLiquid = GetLiquidTypeId(groupLiquid + 1);

                        if (groupLiquid != 0)
                            liquflags |= 2;
                    }
                    else if (fourcc == "MOPY")
                    {
                        mopy_size = (int)size;
                        nTriangles = (int)size / 2;
                        MOPY = reader.ReadString((int)size);
                    }
                    else if (fourcc == "MOVI")
                    {
                        MOVI = new ushort[size / 2];
                        for (var i = 0; i < size / 2; ++i)
                            MOVI[i] = reader.ReadUInt16();
                    }
                    else if (fourcc == "MOVT")
                    {
                        MOVT = new float[size / 4];
                        for (var i = 0; i < size / 4; ++i)
                            MOVT[i] = reader.ReadSingle();

                        nVertices = size / 12;
                    }
                    else if (fourcc == "MONR")
                    {
                    }
                    else if (fourcc == "MOTV")
                    {
                    }
                    else if (fourcc == "MOBA")
                    {
                        MOBA = new ushort[size / 2];
                        moba_size = (int)(size / 2);

                        for (var i = 0; i < size / 2; ++i)
                            MOBA[i] = reader.ReadUInt16();
                    }
                    else if (fourcc == "MODR")
                    {
                        for (var i = 0; i < size / 2; ++i)
                            DoodadReferences.Add(reader.Read<ushort>());
                    }
                    else if (fourcc == "MLIQ")
                    {
                        liquflags |= 1;
                        hlq = reader.Read<WMOLiquidHeader>();
                        LiquEx_size = 8 * hlq.xverts * hlq.yverts;
                        LiquEx = new WMOLiquidVert[hlq.xverts * hlq.yverts];
                        for (var i = 0; i < hlq.xverts * hlq.yverts; ++i)
                            LiquEx[i] = reader.Read<WMOLiquidVert>();

                        int nLiquBytes = hlq.xtiles * hlq.ytiles;
                        LiquBytes = reader.ReadBytes(nLiquBytes);

                        // Determine legacy liquid type
                        if (groupLiquid == 0)
                        {
                            for (int i = 0; i < hlq.xtiles * hlq.ytiles; ++i)
                            {
                                if ((LiquBytes[i] & 0xF) != 15)
                                {
                                    groupLiquid = GetLiquidTypeId((uint)(LiquBytes[i] & 0xF) + 1);
                                    break;
                                }
                            }
                        }

                        /* std::ofstream llog("Buildings/liquid.log", ios_base::out | ios_base::app);
                        llog << filename;
                        llog << "\nbbox: " << bbcorn1[0] << ", " << bbcorn1[1] << ", " << bbcorn1[2] << " | " << bbcorn2[0] << ", " << bbcorn2[1] << ", " << bbcorn2[2];
                        llog << "\nlpos: " << hlq->pos_x << ", " << hlq->pos_y << ", " << hlq->pos_z;
                        llog << "\nx-/yvert: " << hlq->xverts << "/" << hlq->yverts << " size: " << size << " expected size: " << 30 + hlq->xverts*hlq->yverts*8 + hlq->xtiles*hlq->ytiles << std::endl;
                        llog.close(); */
                    }
                    reader.BaseStream.Seek((int)nextpos, SeekOrigin.Begin);
                }
            }

            return true;
        }

19 Source : SimpleJSON.cs
with GNU General Public License v3.0
from Cytoid

public static JSONNode Deserialize(System.IO.BinaryReader aReader)
        {
            JSONBinaryTag type = (JSONBinaryTag)aReader.ReadByte();
            switch(type)
            {
            case JSONBinaryTag.Array:
            {
                int count = aReader.ReadInt32();
                JSONArray tmp = new JSONArray();
                for(int i = 0; i < count; i++)
                    tmp.Add(Deserialize(aReader));
                return tmp;
            }
            case JSONBinaryTag.Clreplaced:
            {
                int count = aReader.ReadInt32();                
                JSONClreplaced tmp = new JSONClreplaced();
                for(int i = 0; i < count; i++)
                {
                    string key = aReader.ReadString();
                    var val = Deserialize(aReader);
                    tmp.Add(key, val);
                }
                return tmp;
            }
            case JSONBinaryTag.Value:
            {
                return new JSONData(aReader.ReadString());
            }
            case JSONBinaryTag.IntValue:
            {
                return new JSONData(aReader.ReadInt32());
            }
            case JSONBinaryTag.DoubleValue:
            {
                return new JSONData(aReader.ReadDouble());
            }
            case JSONBinaryTag.BoolValue:
            {
                return new JSONData(aReader.ReadBoolean());
            }
            case JSONBinaryTag.FloatValue:
            {
                return new JSONData(aReader.ReadSingle());
            }
 
            default:
            {
                throw new Exception("Error deserializing JSON. Unknown tag: " + type);
            }
            }
        }

19 Source : NxoLoader.cs
with MIT License
from daeken

public static Nxo Load(Stream stream) {
			var br = new BinaryReader(stream);
			switch(br.ReadString(4)) {
				case "NSO0": return new Nso(br);
				case { } x: throw new NotSupportedException($"Unknown magic to NXO loader: {x.ToPrettyString()}");
				default: throw new NotSupportedException();
			}
		}

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

private static object ReadObject(this BinaryReader br, Type type, ITypeResolver typeResolver, IReadObjectSink emitter = null)
		{
			if (br.ReadIsNull())
				return null;

			var members = GetMembers(type);

			emitter?.StartedReadingObject(type, members);

			var writer = GetPropertyWriter(type);
			var instance = Instancing.CreateInstance(type);
			
			var count = br.ReadInt32();
			for (var i = 0; i < count; i++)
			{
				if (br.ReadIsNull())
					continue;

				var member = members[i];

				if (!member.CanWrite)
					throw new InvalidOperationException($"{nameof(WriteObject)} wrote an invalid buffer");

				var typeName = br.ReadString();
				var itemType = Type.GetType(typeName) ?? typeResolver?.FindByFullName(typeName);
				if(itemType == null)
					throw new TypeLoadException();

				var item = ReadValue(itemType, br, typeResolver);

				emitter?.ReadMember(type, member.Name, itemType, item);

				writer.TrySetValue(instance, member.Name, item);
			}

			return instance;
		}

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 : PreferencesBackend.cs
with GNU General Public License v3.0
from deathkiller

void IDualityBackend.Init()
        {
            data = new Dictionary<string, object>();

            string path = GetSettingsPath();
            if (!FileOp.Exists(path)) {
                dirty = true;
                return;
            }

            try {
                using (Stream s = FileOp.Open(path, FileAccessMode.Read))
                using (BinaryReader r = new BinaryReader(s)) {
                    ushort n = r.ReadUInt16();

                    for (ushort i = 0; i < n; i++) {
                        string key = r.ReadString();
                        byte type = r.ReadByte();

                        switch (type) {
                            case 0: data[key] = r.ReadString(); break; // String
                            case 1: data[key] = r.ReadBoolean(); break; // Bool
                            case 2: data[key] = r.ReadByte(); break; // Byte
                            case 3: data[key] = r.ReadInt32(); break; // Int
                            case 4: data[key] = r.ReadInt64(); break; // Long
                            case 5: data[key] = r.ReadInt16(); break; // Short
                            case 6: data[key] = r.ReadUInt32(); break; // Uint

                            case 10: { // String Array
                                byte count = r.ReadByte();
                                string[] values = new string[count];
                                for (int j = 0; j < count; j++) {
                                    values[j] = r.ReadString();
                                }
                                data[key] = values;
                                break;
                            }
                            case 11: { // Bool Array
                                byte count = r.ReadByte();
                                bool[] values = new bool[count];
                                for (int j = 0; j < count; j++) {
                                    values[j] = r.ReadBoolean();
                                }
                                data[key] = values;
                                break;
                            }
                            case 12: { // Byte Array
                                byte count = r.ReadByte();
                                byte[] values = new byte[count];
                                for (int j = 0; j < count; j++) {
                                    values[j] = r.ReadByte();
                                }
                                data[key] = values;
                                break;
                            }
                            case 13: { // Int Array
                                byte count = r.ReadByte();
                                int[] values = new int[count];
                                for (int j = 0; j < count; j++) {
                                    values[j] = r.ReadInt32();
                                }
                                data[key] = values;
                                break;
                            }
                            case 14: { // Long Array
                                byte count = r.ReadByte();
                                long[] values = new long[count];
                                for (int j = 0; j < count; j++) {
                                    values[j] = r.ReadInt64();
                                }
                                data[key] = values;
                                break;
                            }
                            case 15: { // Short Array
                                byte count = r.ReadByte();
                                short[] values = new short[count];
                                for (int j = 0; j < count; j++) {
                                    values[j] = r.ReadInt16();
                                }
                                data[key] = values;
                                break;
                            }
                            case 16: { // Uint Array
                                byte count = r.ReadByte();
                                uint[] values = new uint[count];
                                for (int j = 0; j < count; j++) {
                                    values[j] = r.ReadUInt32();
                                }
                                data[key] = values;
                                break;
                            }
                        }
                    }
                }
            } catch (Exception ex) {
                Log.Write(LogType.Error, "Can't load preferences: " + ex);
            }
        }

19 Source : PreferencesBackend.cs
with GNU General Public License v3.0
from deathkiller

void IDualityBackend.Init()
        {
            data = new Dictionary<string, object>();

            sharedPrefs = Application.Context.GetSharedPreferences(App.replacedemblyreplacedle, FileCreationMode.Private);

            string base64 = sharedPrefs.GetString("Root", null);
            if (string.IsNullOrEmpty(base64)) {
                // No preferences found
                dirty = true;
                return;
            }

            byte[] buffer = Base64.Decode(base64, Base64Flags.NoPadding | Base64Flags.NoWrap);

            using (BinaryReader r = new BinaryReader(new MemoryStream(buffer, false))) {
                ushort n = r.ReadUInt16();

                for (ushort i = 0; i < n; i++) {
                    string key = r.ReadString();
                    byte type = r.ReadByte();

                    switch (type) {
                        case 0: data[key] = r.ReadString(); break; // String
                        case 1: data[key] = r.ReadBoolean(); break; // Bool
                        case 2: data[key] = r.ReadByte(); break; // Byte
                        case 3: data[key] = r.ReadInt32(); break; // Int
                        case 4: data[key] = r.ReadInt64(); break; // Long
                        case 5: data[key] = r.ReadInt16(); break; // Short
                        case 6: data[key] = r.ReadUInt32(); break; // Uint

                        case 10: { // String Array
                            byte count = r.ReadByte();
                            string[] values = new string[count];
                            for (int j = 0; j < count; j++) {
                                values[j] = r.ReadString();
                            }
                            data[key] = values;
                            break;
                        }
                        case 11: { // Bool Array
                            byte count = r.ReadByte();
                            bool[] values = new bool[count];
                            for (int j = 0; j < count; j++) {
                                values[j] = r.ReadBoolean();
                            }
                            data[key] = values;
                            break;
                        }
                        case 12: { // Byte Array
                            byte count = r.ReadByte();
                            byte[] values = new byte[count];
                            for (int j = 0; j < count; j++) {
                                values[j] = r.ReadByte();
                            }
                            data[key] = values;
                            break;
                        }
                        case 13: { // Int Array
                            byte count = r.ReadByte();
                            int[] values = new int[count];
                            for (int j = 0; j < count; j++) {
                                values[j] = r.ReadInt32();
                            }
                            data[key] = values;
                            break;
                        }
                        case 14: { // Long Array
                            byte count = r.ReadByte();
                            long[] values = new long[count];
                            for (int j = 0; j < count; j++) {
                                values[j] = r.ReadInt64();
                            }
                            data[key] = values;
                            break;
                        }
                        case 15: { // Short Array
                            byte count = r.ReadByte();
                            short[] values = new short[count];
                            for (int j = 0; j < count; j++) {
                                values[j] = r.ReadInt16();
                            }
                            data[key] = values;
                            break;
                        }
                        case 16: { // Uint Array
                            byte count = r.ReadByte();
                            uint[] values = new uint[count];
                            for (int j = 0; j < count; j++) {
                                values[j] = r.ReadUInt32();
                            }
                            data[key] = values;
                            break;
                        }
                    }
                }
            }
        }

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 : SecurityFile.cs
with GNU General Public License v3.0
from DeepHydro

public void Read()
        {
            FileStream fs = new FileStream(_FileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
            BinaryReader br = new BinaryReader(fs);
            var str = br.ReadString();
            Mac = br.ReadString();
            str = br.ReadString();
            Date = DateTime.Parse(str);
            AuthenticationCode = br.ReadString();
            Authenticated = br.ReadBoolean();
            br.Close();
            fs.Close();
        }

19 Source : BufferStream.cs
with MIT License
from dereksorensen

public string GetString()
        {
            return _reader.ReadString();
        }

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

private static object ReadList(BinaryReader reader, bool isNull, out Type objectType) {
			var typeName = reader.ReadString();
			objectType = Type.GetType(typeName, true, true);

			MethodInfo addMethod;

			if (objectType.IsGenericTypeOf(typeof(IList<>))) {
				var parameterType = ReadGenericArgumentType(reader);
				var listType = objectType.MakeGenericType(parameterType);

				objectType = listType;

				if (isNull)
					return null;

				addMethod = objectType.GetRuntimeMethod("Add", new Type[] {parameterType});
			} else if (typeof(IList).GetTypeInfo().IsreplacedignableFrom(objectType.GetTypeInfo())) {
				if (isNull)
					return null;

				addMethod = objectType.GetRuntimeMethod("Add", new Type[] {typeof(object)});
			} else {
				throw new NotSupportedException();
			}

			var list = Activator.CreateInstance(objectType);

			var count = reader.ReadInt32();
			for (int i = 0; i < count; i++) {
				Type itemType;
				var item = ReadObject(reader, out itemType);

				addMethod.Invoke(list, new object[] {item});
			}

			return list;
		}

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

private static object ReadArray(BinaryReader reader, bool isNull, out Type objectType) {
			var elemObjType = (ObjectTypeCode) reader.ReadByte();
			Type elementType;

			if (elemObjType == ObjectTypeCode.Primitive) {
				var primitiveTypeCode = (PrimitiveTypeCode) reader.ReadByte();
				elementType = SerializerUtil.GetObjectType(primitiveTypeCode);
			} else if (elemObjType == ObjectTypeCode.Serializable) {
				var typeName = reader.ReadString();
				elementType = Type.GetType(typeName, true, true);
			} else {
				throw new NotSupportedException();
			}

			objectType = elementType.MakeArrayType();

			if (isNull)
				return null;

			var length = reader.ReadInt32();
			var array = Array.CreateInstance(elementType, length);

			for (int i = 0; i < length; i++) {
				Type itemType;
				var item = ReadObject(reader, out itemType);

				if (!elementType.GetTypeInfo().IsreplacedignableFrom(itemType.GetTypeInfo()))
					throw new SerializationException();

				array.SetValue(item, i);
			}

			return array;
		}

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

private static object ReadSerialized(BinaryReader reader, bool isNull, out Type objectType) {
			var typeName = reader.ReadString();
			objectType = Type.GetType(typeName, true, true);

			if (isNull)
				return null;

			var type = objectType;
			if (!SerializerUtil.IsInstantiable(objectType)) {
				var realTypeName = reader.ReadString();
				type = Type.GetType(realTypeName, true, true);
			}

			var memberCount = reader.ReadInt32();
			var info = new SerializationInfo(objectType);

			for (int i = 0; i < memberCount; i++) {
				ReadMember(reader, info);
			}

			return SerializerUtil.CreateObject(type, info);
		}

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

private static void ReadMember(BinaryReader reader, SerializationInfo info) {
			var memberName = reader.ReadString();
			Type memberType;
			var value = ReadObject(reader, out memberType);

			info.SetValue(memberName, memberType, value);
		}

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

private static object ReadEnum(BinaryReader reader, bool isNull, out Type objectType) {
			var typeName = reader.ReadString();
			objectType = Type.GetType(typeName, true, true);

			Type primitiveType;
			var primitive = ReadPrimitive(reader, isNull, out primitiveType);

			return Enum.ToObject(objectType, primitive);
		}

See More Examples