System.IO.BinaryWriter.Close()

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

351 Examples 7

19 Source : PacketLogger.cs
with BSD 3-Clause "New" or "Revised" License
from 3gstudent

public void Dispose()
        {
            if (this.m_WriteStream != null)
            {
                this.m_WriteStream.Close();
                this.m_WriteStream.Dispose();
                this.m_WriteStream = null;
            }
            if (this.m_ReadStream != null)
            {
                this.m_ReadStream.Close();
                this.m_ReadStream.Dispose();
                this.m_ReadStream = null;
            }
        }

19 Source : BaiduMap_main.cs
with MIT License
from 734843327

void saveData(WWW www, string name)//没用
    {

        //以下代码作用为:将数据保存到本地生成json文件
        string filename = name +"南开内"+UnityEngine.Random.Range(0.0f, 5.0f).ToString();
       
        byte[] stream = www.bytes;
        FileStream fs = new FileStream(filename, FileMode.CreateNew);
        // Create the writer for data.
        BinaryWriter w = new BinaryWriter(fs);
        // Write data to Test.data.
        w.Write(stream);
        w.Close();
        fs.Close();
    }

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

public byte[] Serialize(params object[] data)
    {
        MemoryStream Stream = new MemoryStream();
        BinaryWriter Writer = new BinaryWriter(Stream, Encoding.UTF8);
        byte Current = 0;

        Writer.Write(Convert.ToByte(data.Length));

        for (int I = 0; I <= data.Length - 1; I++)
        {
            Current = Table[data[I].GetType()];
            Writer.Write(Current);

            switch (Current)
            {
                case 0:
                    Writer.Write((bool)data[I]);
                    break;
                case 1:
                    Writer.Write((byte)data[I]);
                    break;
                case 2:
                    Writer.Write(((byte[])data[I]).Length);
                    Writer.Write((byte[])data[I]);
                    break;
                case 3:
                    Writer.Write((char)data[I]);
                    break;
                case 4:
                    Writer.Write(((char[])data[I]).ToString());
                    break;
                case 5:
                    Writer.Write((decimal)data[I]);
                    break;
                case 6:
                    Writer.Write((double)data[I]);
                    break;
                case 7:
                    Writer.Write((int)data[I]);
                    break;
                case 8:
                    Writer.Write((long)data[I]);
                    break;
                case 9:
                    Writer.Write((sbyte)data[I]);
                    break;
                case 10:
                    Writer.Write((short)data[I]);
                    break;
                case 11:
                    Writer.Write((float)data[I]);
                    break;
                case 12:
                    Writer.Write((string)data[I]);
                    break;
                case 13:
                    Writer.Write((uint)data[I]);
                    break;
                case 14:
                    Writer.Write((ulong)data[I]);
                    break;
                case 15:
                    Writer.Write((ushort)data[I]);
                    break;
                case 16:
                    Writer.Write(((System.DateTime)data[I]).ToBinary());
                    break;
            }
        }

        Writer.Close();
        return Stream.ToArray();
    }

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

public virtual byte[] AppendAndSave(Stream newData, Stream originalData) {
            originalData.Seek(offset + 60, SeekOrigin.Begin);
            var OldChunkCompressedSizes = new byte[(entry_count - 1) * 4];
            originalData.Read(OldChunkCompressedSizes, 0, OldChunkCompressedSizes.Length);

            var lastCunkCompressedSize = originalData.ReadByte() | originalData.ReadByte() << 8 | originalData.ReadByte() << 16 | originalData.ReadByte() << 24; //ReadInt32

            var lastCunkDecompressedSize = uncompressed_size - (chunk_size * (entry_count - 1));

            uncompressed_size = (int)(size_decompressed += newData.Length);
            entry_count = uncompressed_size / chunk_size;
            if (uncompressed_size % chunk_size != 0) entry_count++;
            head_size = entry_count * 4 + 48;

            var msToSave = new MemoryStream();
            var bw = new BinaryWriter(msToSave);

            msToSave.Seek(60 + (entry_count * 4), SeekOrigin.Begin);
            var o = new byte[compressed_size - lastCunkCompressedSize];
            originalData.Read(o, 0, o.Length);
            bw.Write(o);

            var lastChunkCompressedData = new byte[lastCunkCompressedSize];
            originalData.Read(lastChunkCompressedData, 0, lastCunkCompressedSize);
            var lastCunkDecompressedData = new byte[lastCunkDecompressedSize + 64];
			_ = OodleLZ_Decompress(lastChunkCompressedData, lastCunkCompressedSize, lastCunkDecompressedData, lastCunkDecompressedSize, 0, 0, 0, IntPtr.Zero, 0, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, 0, 3);

            newData.Seek(0, SeekOrigin.Begin);
            compressed_size -= lastCunkCompressedSize;
            var NewChunkCompressedSizes = new int[entry_count - (OldChunkCompressedSizes.Length / 4)];

            var FirstNewDataChunk = new byte[Math.Min(chunk_size - lastCunkDecompressedSize, newData.Length)];
            newData.Read(FirstNewDataChunk, 0, FirstNewDataChunk.Length);
            FirstNewDataChunk = lastCunkDecompressedData.Take(lastCunkDecompressedSize).Concat(FirstNewDataChunk).ToArray();
            var CompressedChunk = new byte[FirstNewDataChunk.Length + 548];
            var CompressedLength = OodleLZ_Compress(encoder, FirstNewDataChunk, FirstNewDataChunk.Length, CompressedChunk, Compression_Level, IntPtr.Zero, 0, 0, IntPtr.Zero, 0);
            compressed_size += NewChunkCompressedSizes[0] = CompressedLength;
            bw.Write(CompressedChunk, 0, CompressedLength);
            for (var i = 1; i < NewChunkCompressedSizes.Length; i++) {
                var size = (i + 1 == NewChunkCompressedSizes.Length) ? uncompressed_size - (chunk_size * (entry_count - 1)) : chunk_size;
                var b = new byte[size];
                newData.Read(b, 0, size);
                var by = new byte[b.Length + 548];
                var l = OodleLZ_Compress(encoder, b, size, by, Compression_Level, IntPtr.Zero, 0, 0, IntPtr.Zero, 0);
                compressed_size += NewChunkCompressedSizes[i] = l;
                bw.Write(by, 0, l);
            }
            size_compressed = compressed_size;

            msToSave.Seek(60, SeekOrigin.Begin);
            bw.Write(OldChunkCompressedSizes);
            for (var i = 0; i < NewChunkCompressedSizes.Length; i++)
                bw.Write(NewChunkCompressedSizes[i]);

            msToSave.Seek(0, SeekOrigin.Begin);
            bw.Write(uncompressed_size);
            bw.Write(compressed_size);
            bw.Write(head_size);
            bw.Write((uint)encoder);
            bw.Write(unknown);
            bw.Write(size_decompressed);
            bw.Write(size_compressed);
            bw.Write(entry_count);
            bw.Write(chunk_size);
            bw.Write(unknown3);
            bw.Write(unknown4);
            bw.Write(unknown5);
            bw.Write(unknown6);

            bw.Flush();
            var result = msToSave.ToArray();
            bw.Close();
            return result;
        }

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

public virtual void Save(Stream newData, string savePath) {
            var bw = new BinaryWriter(File.OpenWrite(savePath ?? path));

            uncompressed_size = (int)(size_decompressed = newData.Length);
            entry_count = uncompressed_size / chunk_size;
            if (uncompressed_size % chunk_size != 0) entry_count++;
            head_size = entry_count * 4 + 48;

            bw.BaseStream.Seek(60 + entry_count * 4, SeekOrigin.Begin);
            newData.Seek(0, SeekOrigin.Begin);
            compressed_size = 0;
            var chunks = new int[entry_count];
            for (var i = 0; i < entry_count; i++) {
                var b = new byte[i + 1 == entry_count ? uncompressed_size - (entry_count - 1) * chunk_size : chunk_size];
                newData.Read(b, 0, b.Length);
                var by = new byte[b.Length + 548];
                var l = OodleLZ_Compress(encoder, b, b.Length, by, Compression_Level, IntPtr.Zero, 0, 0, IntPtr.Zero, 0);
                compressed_size += chunks[i] = l;
                bw.Write(by, 0, l);
            }
            size_compressed = compressed_size;

            bw.BaseStream.Seek(60, SeekOrigin.Begin);
            foreach (var c in chunks) bw.Write(c);

            bw.BaseStream.Seek(0, SeekOrigin.Begin);
            bw.Write(uncompressed_size);
            bw.Write(compressed_size);
            bw.Write(head_size);
            bw.Write((uint)encoder);
            bw.Write(unknown);
            bw.Write(size_decompressed);
            bw.Write(size_compressed);
            bw.Write(entry_count);
            bw.Write(chunk_size);
            bw.Write(unknown3);
            bw.Write(unknown4);
            bw.Write(unknown5);
            bw.Write(unknown6);

            bw.Flush();
            bw.Close();
        }

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

public virtual byte[] Save(Stream newData) {
            var msToSave = new MemoryStream();
            var bw = new BinaryWriter(msToSave);

            uncompressed_size = (int)(size_decompressed = newData.Length);
            entry_count = uncompressed_size / chunk_size;
            if (uncompressed_size % chunk_size != 0) entry_count++;
            head_size = entry_count * 4 + 48;

            msToSave.Seek(60 + (entry_count * 4), SeekOrigin.Begin);
            newData.Seek(0, SeekOrigin.Begin);
            compressed_size = 0;
            var chunks = new int[entry_count];
            for (var i = 0; i < entry_count; i++) {
                var b = new byte[i + 1 == entry_count ? uncompressed_size - (entry_count - 1) * chunk_size : chunk_size];
                newData.Read(b, 0, b.Length);
                var by = new byte[b.Length + 548];
                var l = OodleLZ_Compress(encoder, b, b.Length, by, Compression_Level, IntPtr.Zero, 0, 0, IntPtr.Zero, 0);
                compressed_size += chunks[i] = l;
                bw.Write(by, 0, l);
            }
            size_compressed = compressed_size;

            msToSave.Seek(60, SeekOrigin.Begin);
            for (var i = 0; i < entry_count; i++)
                bw.Write(chunks[i]);

            msToSave.Seek(0, SeekOrigin.Begin);
            bw.Write(uncompressed_size);
            bw.Write(compressed_size);
            bw.Write(head_size);
            bw.Write((uint)encoder);
            bw.Write(unknown);
            bw.Write(size_decompressed);
            bw.Write(size_compressed);
            bw.Write(entry_count);
            bw.Write(chunk_size);
            bw.Write(unknown3);
            bw.Write(unknown4);
            bw.Write(unknown5);
            bw.Write(unknown6);

            bw.Flush();
            var result = msToSave.ToArray();
            bw.Close();
            return result;
        }

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

public virtual void Save(string path)
        {
            var bw = new BinaryWriter(new MemoryStream());
            bw.Write(Bundles.Length);
            foreach (var b in Bundles)
            {
                bw.Write(b.NameLength);
                bw.Write(Encoding.UTF8.GetBytes(b.Name), 0, b.NameLength);
                bw.Write(b.UncompressedSize);
            }

            bw.Write(Files.Length);
            foreach (var f in Files)
            {
                bw.Write(f.NameHash);
                bw.Write(f.BundleIndex);
                bw.Write(f.Offset);
                bw.Write(f.Size);
            }

            bw.Write(Directorys.Length);
            foreach (var d in Directorys)
            {
                bw.Write(d.NameHash);
                bw.Write(d.Offset);
                bw.Write(d.Size);
                bw.Write(d.RecursiveSize);
            }

            bw.Write(directoryBundleData);
            bw.Flush();

            BundleContainer.Save(bw.BaseStream, path);
            bw.Close();
        }

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

public virtual void Dispose()
		{
            Writer.Flush();
            Writer.Close();
            Reader.Close();
        }

19 Source : BsonBinaryWriter.cs
with MIT License
from akaskela

public void Close()
        {
#if !(DOTNET || PORTABLE40 || PORTABLE)
            _writer.Close();
#else
            _writer.Dispose();
#endif
        }

19 Source : Utils.cs
with Apache License 2.0
from AmpScm

public static void WriteEmbeddedResourceToBinaryFile(replacedembly replacedembly, string embeddedResourceName, string fileName)
        {
            // Get file contents
            Stream stream = replacedembly.GetManifestResourceStream(embeddedResourceName);
            if (stream == null)
                throw new InvalidOperationException("Failed to get embedded resource '" + embeddedResourceName + "' from replacedembly '" + replacedembly.FullName);

            // Write to file
            BinaryWriter sw = null;
            FileStream fs = null;
            try
            {
                byte[] fileContentsAsBytes = new byte[stream.Length];
                stream.Read(fileContentsAsBytes, 0, (int)stream.Length);

                FileMode mode = FileMode.CreateNew;
                if (File.Exists(fileName))
                {
                    mode = FileMode.Truncate;
                }

                fs = new FileStream(fileName, mode);

                sw = new BinaryWriter(fs);
                sw.Write(fileContentsAsBytes);
            }
            finally
            {
                if (fs != null)
                {
                    fs.Close();
                }
                if (sw != null)
                {
                    sw.Close();
                }
            }
        }

19 Source : CloseHandleResponse.cs
with GNU General Public License v3.0
from andreluis034

public byte[] Serialize()
        {
            MemoryStream ms = new MemoryStream();
            BinaryWriter br = new BinaryWriter(ms);
            br.Write(Result ? 1 : 0);

            br.Close();
            return ms.ToArray();
        }

19 Source : GetSymbolsFromFileResponse.cs
with GNU General Public License v3.0
from andreluis034

public byte[] Serialize()
        {
            MemoryStream ms = new MemoryStream();
            BinaryWriter br = new BinaryWriter(ms);
            br.Write(0L);

            br.Close();
            return ms.ToArray();
        }

19 Source : HandleResponse.cs
with GNU General Public License v3.0
from andreluis034

public byte[] Serialize()
        {
            MemoryStream ms = new MemoryStream();
            BinaryWriter br = new BinaryWriter(ms);

            br.Write((int)this.Handle);
            br.Close();
            return ms.ToArray();
        }

19 Source : Module32Response.cs
with GNU General Public License v3.0
from andreluis034

public byte[] Serialize()
        {
            MemoryStream ms = new MemoryStream();
            BinaryWriter br = new BinaryWriter(ms);

            br.Write((int)(this.Result ? 1 : 0));
            if (this.Result)
            {
                br.Write((long)ModuleEntry.modBaseAddr);
                br.Write(ModuleEntry.modBaseSize);
                br.Write(ModuleEntry.szModule.Length);
                br.Write(Encoding.UTF8.GetBytes(ModuleEntry.szModule));
            }
            else 
            {
                br.Write(0L);//Base Address
                br.Write(0);//Mod Size
                br.Write(0);//str Size
            }

            br.Close();
            return ms.ToArray();
        }

19 Source : Process32Response.cs
with GNU General Public License v3.0
from andreluis034

public byte[] Serialize()
        {
            MemoryStream ms = new MemoryStream();
            BinaryWriter br = new BinaryWriter(ms);

            br.Write((int)(this.Result ? 1 : 0));
            if (this.Result)
            {
                br.Write((int)ProcessEntry.th32ProcessID);
                br.Write((int)ProcessEntry.szExeFile.Length);
                br.Write(Encoding.UTF8.GetBytes(ProcessEntry.szExeFile));
            }
            else
            {
                br.Write((int)0);
                br.Write((int)0);
            }

            br.Close();
            return ms.ToArray();
        }

19 Source : VirtualQueryExFullResponse.cs
with GNU General Public License v3.0
from andreluis034

public byte[] Serialize()
        {

            MemoryStream ms = new MemoryStream();
            BinaryWriter br = new BinaryWriter(ms);
            br.Write(Regions.Count);
            //The number of bytes return by VirtualQueryEx is the number of bytes written to mbi, if it's 0 it failed
            //But in Cheat engise server 1 is success and 0 is failed
            foreach (var region in Regions)
            {//Yes this is reversed from VirtualQueryEx....
                br.Write((long)region.BaseAddress);
                br.Write((long)region.RegionSize);
                br.Write((int)region.AllocationProtect); // Or Protect
                br.Write((int)region.Type);
            }

            br.Close();
            return ms.ToArray();
        }

19 Source : GetVersionResponse.cs
with GNU General Public License v3.0
from andreluis034

public byte[] Serialize()
        {
            MemoryStream ms = new MemoryStream();
            BinaryWriter br = new BinaryWriter(ms);
            br.Write(version.Length);
            br.Write(Encoding.UTF8.GetBytes(version));

            br.Close();
            return ms.ToArray();
        }

19 Source : ReadProcessMemoryResponse.cs
with GNU General Public License v3.0
from andreluis034

public byte[] Serialize()
        {
            if(this.Compression)
                throw new NotImplementedException("Compression is not implemented");

            MemoryStream ms = new MemoryStream();
            BinaryWriter br = new BinaryWriter(ms);
            br.Write(Data.Length);
            br.Write(Data);
            br.Close();
            return ms.ToArray();
        }

19 Source : VirtualQueryExResponse.cs
with GNU General Public License v3.0
from andreluis034

public byte[] Serialize()
        {

            MemoryStream ms = new MemoryStream();
            BinaryWriter br = new BinaryWriter(ms);
            //The number of bytes return by VirtualQueryEx is the number of bytes written to mbi, if it's 0 it failed
            //But in Cheat engise server 1 is success and 0 is failed
            if (Result > 0)
                br.Write((byte)1);
            else
                br.Write((byte)0);
            //Yes this is reversed from VirtualQueryExFull....
            br.Write((int)MemoryBasicInformation.AllocationProtect);
            br.Write((int)MemoryBasicInformation.Type);
            br.Write((Int64)MemoryBasicInformation.BaseAddress);
            br.Write((Int64)MemoryBasicInformation.RegionSize);

            br.Close();
            return ms.ToArray();
        }

19 Source : WAD.cs
with GNU General Public License v3.0
from anotak

public void Dispose()
		{
			// Not already disposed?
			if(!isdisposed)
			{
				// Flush all changes
				Flush();
                if (filecapacity > filelength)
                {
                    file.SetLength(filelength);
                }
				
				// Clean up
				if(lumps != null) foreach(Lump l in lumps) l.Dispose();
				if(writer != null) writer.Close();
				if(reader != null) reader.Close();
				if(file != null) file.Dispose();
				
				// Done
				isdisposed = true;
			}
		}

19 Source : NavMeshExporter.cs
with MIT License
from AnotherEnd15

private static void WriteFile()
        {
            if (!System.IO.Directory.Exists(outputClientFolder))
            {
                System.IO.Directory.CreateDirectory(outputClientFolder);
            }

            var path = outputClientFolder + SceneManager.GetActiveScene().name + ".bytes";
            var writer = new BinaryWriter(new FileStream(path, FileMode.Create));
            writer.Write('N');
            writer.Write('a');
            writer.Write('v');
            writer.Write('M');
            writer.Write('e');
            writer.Write('s');
            writer.Write('h');
            writer.Write(VERSION);
            writer.Write(vertList.Count);
            foreach (var vert in vertList)
            {
                writer.Write(vert.x);
                writer.Write(vert.y);
                writer.Write(vert.z);
            }

            writer.Write(faceList.Count);
            foreach (var face in faceList)
            {
                writer.Write(face.area);
                writer.Write(face.normalX);
                writer.Write(face.normalZ);
                writer.Write(face.verts.Count);
                foreach (var vert in face.verts)
                {
                    writer.Write(vert.id);
                }
            }

            writer.Write(pairList.Count);
            foreach (var pair in pairList)
            {
                writer.Write(pair.distance);
                writer.Write(pair.firstEdgeFace.id);
                writer.Write(pair.firstEdgeIndex);
                writer.Write(pair.secondEdgeFace.id);
                writer.Write(pair.secondEdgeIndex);
            }

            writer.Flush();
            writer.Close();
            replacedetDatabase.Refresh();
        }

19 Source : NmsTestBytesMessageFacade.cs
with Apache License 2.0
from apache

public void Reset()
        {
            if (bytesOut != null)
            {
                MemoryStream byteStream = new MemoryStream((int) bytesOut.BaseStream.Length);
                bytesOut.BaseStream.Position = 0;
                bytesOut.BaseStream.CopyTo(byteStream);

                content = byteStream.ToArray();

                byteStream.Close();
                bytesOut.Close();
                bytesOut = null;
            }
            else if (bytesIn != null)
            {
                bytesIn.Close();
                bytesIn = null;
            }
        }

19 Source : EndianTest.cs
with Apache License 2.0
from apache

[Test]
        public void TestFloatDontNeedEndianSwitch()
        {
            float value = -1.223F;

            // Convert to int so we can compare to Java version.
            MemoryStream ms = new MemoryStream(4);
            BinaryWriter bw = new BinaryWriter(ms);
            bw.Write(value);
            bw.Close();
            ms = new MemoryStream(ms.ToArray());
            BinaryReader br = new BinaryReader(ms);

            // System.out.println(Integer.toString(Float.floatToIntBits(-1.223F), 16));
            replacedert.AreEqual(-0x406374bc, br.ReadInt32());
        }

19 Source : EndianTest.cs
with Apache License 2.0
from apache

[Test]
        public void TestDoublDontNeedEndianSwitch()
        {
            double value = -1.223D;

            // Convert to int so we can compare to Java version.
            MemoryStream ms = new MemoryStream(4);
            BinaryWriter bw = new BinaryWriter(ms);
            bw.Write(value);
            bw.Close();
            ms = new MemoryStream(ms.ToArray());
            BinaryReader br = new BinaryReader(ms);
            long longVersion = br.ReadInt64();

            // System.out.println(Long.toString(Double.doubleToLongBits(-1.223D), 16));
            replacedert.AreEqual(-0x400c6e978d4fdf3b, longVersion);
        }

19 Source : DeckManager.cs
with MIT License
from Arefu

private void ImportDeck_Click(object Sender, EventArgs Args)
        {
            var Result =
                MessageBox.Show("This WILL Overwrite Any Deck In This Slot, If You Want To Keep It Export The Deck First! Do You Wish To Continue?", "Warning Overwriting Deck!", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
            if (Result == DialogResult.No) return;

            Export_Deck.Enabled = true;
            textBox1.Text = "N/A";

            using (var Writer = new BinaryWriter(File.Open(Save, FileMode.Open, FileAccess.Write)))
            {
                Writer.BaseStream.Position = DeckPos;
                // Writer.Write(new byte[0x130]);

                Writer.Close();
            }
        }

19 Source : Form1.cs
with MIT License
from Arefu

private void DLCToolStripMenuItem_Click(object sender, EventArgs e)
        {
            var MainFile = new LOTD_Archive(true);
            MainFile.Load();

            var Writer = new BinaryWriter(MainFile.Reader.BaseStream);
            var CharacterDataFiles = MainFile.LoadFiles<Char_Data>();
            var DuelDataFiles = MainFile.LoadFiles<Duel_Data>();

            foreach (var Character in CharacterDataFiles)
            {
                foreach (var CharacterItem in Character.Items.Values)
                    CharacterItem.DlcId = -1; //DLC Not Required.

                Writer.BaseStream.Position = Character.File.ArchiveOffset;
                Character.Save(Writer);
            }

            foreach (var Duel in DuelDataFiles)
            {
                foreach (var DuelItem in Duel.Items.Values)
                    DuelItem.DlcId = -1; //DLC Not Reuqired.

                Writer.BaseStream.Position = Duel.File.ArchiveOffset;
                Duel.Save(Writer);
            }

            Writer.Close();
            var save = new Game_Save();
            save.Load();
            save.SetAllCampaignDuels(CampaignDuelState.Complete);
            save.Save();
            MessageBox.Show("Done Unlocking All DLC!\nYou Will Need To Play Through The Story To Unlock The Duels.",
                "All Content Unlocked", MessageBoxButtons.OK, MessageBoxIcon.Information);
        }

19 Source : CanvasSave.aspx.cs
with MIT License
from aspose-pdf

[WebMethod]
        public static string CreateSignature(string imageData)
        {

            var downloadedMessageInfo = new DirectoryInfo(HttpContext.Current.Server.MapPath("Images/Signature/"));

            foreach (FileInfo file in downloadedMessageInfo.GetFiles())
            {
                file.Delete();
            }
            Random random = new Random();
            int rand =  random.Next(1000000);
            string fileNameWitPath = HttpContext.Current.Server.MapPath("Images/Signature/sign"+rand+".png");
            using (FileStream fs = new FileStream(fileNameWitPath, FileMode.Create))
            {
                using (BinaryWriter bw = new BinaryWriter(fs))
                {
                    byte[] data = Convert.FromBase64String(imageData);
                    bw.Write(data);
                    bw.Close();
                }
            }

            return "Signature/sign" + rand + ".png";
        }

19 Source : ArchiveFactory.cs
with GNU General Public License v3.0
from AtomCrafty

public override long ToBinary(YukaArchive data, Stream s) {
			long offset = s.Position;
			BinaryWriter bw = new BinaryWriter(s, Encoding.ASCII, true);

			s.Write(Encoding.ASCII.GetBytes("YKC001\0\0"), 0x00, 0x08);
			bw.Write((uint)0x18);
			s.Write(new byte[0x0C], 0x00, 0x0C);

			// dataoffset, datalength, nameoffset, namelength
			Dictionary<string, uint[]> offsets = new Dictionary<string, uint[]>();

			// Write data sector
			foreach(var file in data.files) {
				uint dataoffset = (uint)s.Position;
				/*
				if(FlagCollection.current.Has('v')) {
					Console.WriteLine("Packing file: " + file.Key);
				}//*/
				MemoryStream ms = data.GetInputStream(file.Key);
				ms.CopyTo(s);
				//s.Write(data, 0, data.Length);
				offsets[file.Key] = (new uint[] { dataoffset, (uint)file.Value.Length, 0, (uint)ShiftJis.GetByteCount(file.Key) + 1 });
			}

			// Write name table
			foreach(var entry in offsets) {
				uint nameoffset = (uint)s.Position;
				var bytes = ShiftJis.GetBytes(entry.Key);
				s.Write(bytes, 0, bytes.Length);
				s.WriteByte(0);
				entry.Value[2] = nameoffset;
			}

			uint indexoffset = (uint)s.Position;

			// Write index
			foreach(var entry in offsets) {
				bw.Write(entry.Value[2]);
				bw.Write(entry.Value[3]);
				bw.Write(entry.Value[0]);
				bw.Write(entry.Value[1]);
				bw.Write((uint)0x00);
			}

			// Update header
			uint indexlength = (uint)(s.Position - indexoffset);
			bw.Seek(0x10, SeekOrigin.Begin);
			bw.Write(indexoffset);
			bw.Write(indexlength);

			bw.Close();
			return s.Position - offset;
		}

19 Source : GraphicsFactory.cs
with GNU General Public License v3.0
from AtomCrafty

public override long ToBinary(YukaGraphics graphics, Stream s) {
			long offset = s.Position;
			BinaryWriter bw = new BinaryWriter(s, Encoding.ASCII, true);
			bw.Write(YKG_HEADER);

			Bitmap colorLayer = graphics.bitmap;
			MemoryStream colorStream = new MemoryStream();
			colorLayer.Save(colorStream, ImageFormat.Png);

			// header length
			int curoffset = 0x40;

			bw.Write(curoffset);
			bw.Write((int)colorStream.Length);

			curoffset += (int)colorStream.Length;

			// no opacity mask
			bw.Write((long)0);

			if(graphics.metaData != null) {
				bw.Write(curoffset);
				bw.Write(graphics.metaData.Length);
			}
			else {
				bw.Write((long)0);
			}

			colorStream.WriteTo(s);
			colorStream.Close();
			/*
			if(alphaLayer != null) {
				alphaStream.WriteTo(s);
			}
			alphaStream.Close();
			*/
			if(graphics.metaData != null) {
				bw.Write(graphics.metaData);
			}

			bw.Close();
			return s.Position - offset;
		}

19 Source : BinaryFileWriter.cs
with MIT License
from Autodesk

public void Close()
        {
            if (_binaryWriter != null)
            {
                _binaryWriter.Close();
                _binaryWriter = null;
            }
        }

19 Source : VCInjectionUtils.cs
with GNU General Public License v3.0
from az64

private static void GetApp5(byte[] ROM, string VCDir)
        {
            BinaryReader a50 = new BinaryReader(File.Open(Path.Combine(VCDir, "5-0"), FileMode.Open));
            BinaryReader a51 = new BinaryReader(File.Open(Path.Combine(VCDir, "5-1"), FileMode.Open));
            BinaryWriter app5 = new BinaryWriter(File.Open(Path.Combine(VCDir, "00000005.app"), FileMode.Create));
            byte[] buffer = new byte[a50.BaseStream.Length];
            a50.Read(buffer, 0, buffer.Length);
            app5.Write(buffer);
            app5.Write(ROM);
            buffer = new byte[a51.BaseStream.Length];
            a51.Read(buffer, 0, buffer.Length);
            app5.Write(buffer);
            a50.Close();
            a51.Close();
            app5.Close();
        }

19 Source : PdfWriter.cs
with MIT License
from azist

public void Dispose()
    {
      m_Writer.Flush();
      m_Writer.Close();
    }

19 Source : LocalFileSystemTests.cs
with MIT License
from azist

[Run]
        public void CreateWriteReadFile_1()
        {
            using(var fs = new LocalFileSystem(NOPApplication.Instance))
            {


              var session = fs.StartSession();

              var dir = session[LOCAL_ROOT] as FileSystemDirectory;

              using (var file = dir.CreateFile(FN2))
              {
                var str = file.FileStream;

                var wri = new BinaryWriter(str);

                wri.Write( "Hello!" );
                wri.Write( true );
                wri.Write( 27.4d );
                wri.Close();
              }

              using (var file = session[fs.CombinePaths(LOCAL_ROOT, FN2)] as FileSystemFile)
              {
                var str = file.FileStream;

                var rdr = new BinaryReader(str);

                Aver.AreEqual( "Hello!", rdr.ReadString());
                Aver.AreEqual( true,     rdr.ReadBoolean());
                Aver.AreEqual( 27.4d,    rdr.ReadDouble());
              }
            }
        }

19 Source : LocalFileSystemTests.cs
with MIT License
from azist

[Run]
        public void CreateWriteCopyReadFile()
        {
            using(var fs = new LocalFileSystem(NOPApplication.Instance))
            {
              var session = fs.StartSession();

              var dir = session[LOCAL_ROOT] as FileSystemDirectory;

              using (var file = dir.CreateFile(FN2))
              {
                var str = file.FileStream;

                var wri = new BinaryWriter(str);

                wri.Write( "Hello!" );
                wri.Write( true );
                wri.Write( 27.4d );
                wri.Close();
              }

              //FN3 copied from FN2 and made readonly
              Aver.IsNotNull( dir.CreateFile(FN3, Path.Combine(LOCAL_ROOT, FN2), true) );


              using (var file = session[fs.CombinePaths(LOCAL_ROOT, FN3)] as FileSystemFile)
              {
                Aver.IsTrue( file.ReadOnly);
                Aver.IsTrue( file.IsReadOnly);

                var str = file.FileStream;

                var rdr = new BinaryReader(str);

                Aver.AreEqual( "Hello!", rdr.ReadString());
                Aver.AreEqual( true,     rdr.ReadBoolean());
                Aver.AreEqual( 27.4d,    rdr.ReadDouble());

                file.ReadOnly = false;

                Aver.IsFalse( file.ReadOnly);
                Aver.IsFalse( file.IsReadOnly);

              }
            }
        }

19 Source : BinaryObjectWriter.cs
with MIT License
from BayatGames

public virtual void Dispose ()
		{
			if ( m_Writer != null )
			{
				m_Writer.Close ();
			}
		}

19 Source : ServerSideCharacter.cs
with MIT License
from bdfzchen2015

public override bool HijackSendData(int whoAmI, int msgType, int remoteClient, int ignoreClient, NetworkText text, int number, float number2, float number3, float number4, int number5, int number6, int number7)
		{
			switch (msgType)
			{
				case MessageID.WorldData:
					if (Main.netMode != 2) // we will not process this message in client-side
					{
						break;
					}

					var memoryStream = new MemoryStream();
					var binaryWriter = new BinaryWriter(memoryStream);
					var position = binaryWriter.BaseStream.Position;
					binaryWriter.BaseStream.Position += 2L;
					binaryWriter.Write(MessageID.WorldData);

					binaryWriter.Write((int)Main.time);
					BitsByte bb3 = 0;
					bb3[0] = Main.dayTime;
					bb3[1] = Main.bloodMoon;
					bb3[2] = Main.eclipse;
					binaryWriter.Write(bb3);
					binaryWriter.Write((byte)Main.moonPhase);
					binaryWriter.Write((short)Main.maxTilesX);
					binaryWriter.Write((short)Main.maxTilesY);
					binaryWriter.Write((short)Main.spawnTileX);
					binaryWriter.Write((short)Main.spawnTileY);
					binaryWriter.Write((short)Main.worldSurface);
					binaryWriter.Write((short)Main.rockLayer);
					binaryWriter.Write(Main.worldID);
					binaryWriter.Write(Main.worldName);
					binaryWriter.Write(Main.ActiveWorldFileData.UniqueId.ToByteArray());
					binaryWriter.Write(Main.ActiveWorldFileData.WorldGeneratorVersion);
					binaryWriter.Write((byte)Main.moonType);
					binaryWriter.Write((byte)WorldGen.treeBG);
					binaryWriter.Write((byte)WorldGen.corruptBG);
					binaryWriter.Write((byte)WorldGen.jungleBG);
					binaryWriter.Write((byte)WorldGen.snowBG);
					binaryWriter.Write((byte)WorldGen.hallowBG);
					binaryWriter.Write((byte)WorldGen.crimsonBG);
					binaryWriter.Write((byte)WorldGen.desertBG);
					binaryWriter.Write((byte)WorldGen.oceanBG);
					binaryWriter.Write((byte)Main.iceBackStyle);
					binaryWriter.Write((byte)Main.jungleBackStyle);
					binaryWriter.Write((byte)Main.hellBackStyle);
					binaryWriter.Write(Main.windSpeedSet);
					binaryWriter.Write((byte)Main.numClouds);
					for (var k = 0; k < 3; k++)
					{
						binaryWriter.Write(Main.treeX[k]);
					}
					for (var l = 0; l < 4; l++)
					{
						binaryWriter.Write((byte)Main.treeStyle[l]);
					}
					for (var m = 0; m < 3; m++)
					{
						binaryWriter.Write(Main.caveBackX[m]);
					}
					for (var n = 0; n < 4; n++)
					{
						binaryWriter.Write((byte)Main.caveBackStyle[n]);
					}
					if (!Main.raining)
					{
						Main.maxRaining = 0f;
					}
					binaryWriter.Write(Main.maxRaining);
					BitsByte bb4 = 0;
					bb4[0] = WorldGen.shadowOrbSmashed;
					bb4[1] = NPC.downedBoss1;
					bb4[2] = NPC.downedBoss2;
					bb4[3] = NPC.downedBoss3;
					bb4[4] = Main.hardMode;
					bb4[5] = NPC.downedClown;
					bb4[6] = true; // ssc mode here
					bb4[7] = NPC.downedPlantBoss;
					binaryWriter.Write(bb4);
					BitsByte bb5 = 0;
					bb5[0] = NPC.downedMechBoss1;
					bb5[1] = NPC.downedMechBoss2;
					bb5[2] = NPC.downedMechBoss3;
					bb5[3] = NPC.downedMechBossAny;
					bb5[4] = Main.cloudBGActive >= 1f;
					bb5[5] = WorldGen.crimson;
					bb5[6] = Main.pumpkinMoon;
					bb5[7] = Main.snowMoon;
					binaryWriter.Write(bb5);
					BitsByte bb6 = 0;
					bb6[0] = Main.expertMode;
					bb6[1] = Main.fastForwardTime;
					bb6[2] = Main.slimeRain;
					bb6[3] = NPC.downedSlimeKing;
					bb6[4] = NPC.downedQueenBee;
					bb6[5] = NPC.downedFishron;
					bb6[6] = NPC.downedMartians;
					bb6[7] = NPC.downedAncientCultist;
					binaryWriter.Write(bb6);
					BitsByte bb7 = 0;
					bb7[0] = NPC.downedMoonlord;
					bb7[1] = NPC.downedHalloweenKing;
					bb7[2] = NPC.downedHalloweenTree;
					bb7[3] = NPC.downedChristmasIceQueen;
					bb7[4] = NPC.downedChristmreplacedantank;
					bb7[5] = NPC.downedChristmasTree;
					bb7[6] = NPC.downedGolemBoss;
					bb7[7] = BirthdayParty.PartyIsUp;
					binaryWriter.Write(bb7);
					BitsByte bb8 = 0;
					bb8[0] = NPC.downedPirates;
					bb8[1] = NPC.downedFrost;
					bb8[2] = NPC.downedGoblins;
					bb8[3] = Sandstorm.Happening;
					bb8[4] = DD2Event.Ongoing;
					bb8[5] = DD2Event.DownedInvasionT1;
					bb8[6] = DD2Event.DownedInvasionT2;
					bb8[7] = DD2Event.DownedInvasionT3;
					binaryWriter.Write(bb8);
					binaryWriter.Write((sbyte)Main.invasionType);
					if (!ModNet.AllowVanillaClients)
					{
						// We have to call `WorldIO.SendModData(binaryWriter)` using reflection
						var type = typeof(Main).replacedembly.GetType("Terraria.ModLoader.IO.WorldIO");
						var method = type.GetMethod("SendModData", new[] {typeof(BinaryWriter)});
						method.Invoke(null, new object[] {binaryWriter});
					}
					binaryWriter.Write(SocialAPI.Network != null ? SocialAPI.Network.GetLobbyId() : 0UL);
					binaryWriter.Write(Sandstorm.IntendedSeverity);

					var currentPosition = (int)binaryWriter.BaseStream.Position;
					binaryWriter.BaseStream.Position = position;
					binaryWriter.Write((short)currentPosition);
					binaryWriter.BaseStream.Position = currentPosition;
					var data = memoryStream.ToArray();

					binaryWriter.Close();

					if (remoteClient == -1)
					{
						for (var index = 0; index < 256; index++)
						{
							if (index != ignoreClient && (NetMessage.buffer[index].broadcast || Netplay.Clients[index].State >= 3 && msgType == 10) && Netplay.Clients[index].IsConnected())
							{
								try
								{
									NetMessage.buffer[index].spamCount++;
									Main.txMsg++;
									Main.txData += currentPosition;
									Main.txMsgType[msgType]++;
									Main.txDataType[msgType] += currentPosition;
									Netplay.Clients[index].Socket.AsyncSend(data, 0, data.Length,
										Netplay.Clients[index].ServerWriteCallBack);
								}
								catch
								{
									// ignored
								}
							}
						}
					}
					else
					{
						try
						{
							Netplay.Clients[remoteClient].Socket.AsyncSend(data, 0, data.Length,
								Netplay.Clients[remoteClient].ServerWriteCallBack);
						}
						catch
						{
							// ignored
						}
					}

					return true;

				default:
					break;
			}

			return false;
		}

19 Source : Form1.cs
with MIT License
from berryelectronics

private void buttonFirmwareSave_Click(object sender, EventArgs e)
        {
            sfd.ShowDialog();

            Form.ActiveForm.Enabled = false;

            BinaryReader tempFile = new BinaryReader(File.Open(tempFilePath, FileMode.Open));
            BinaryWriter newFirmwareFile = new BinaryWriter(File.Open(sfd.FileName, FileMode.Create));

            tempFile.BaseStream.Position = 0;
            newFirmwareFile.BaseStream.Position = 0;

            for (int i = 0; i < tempFile.BaseStream.Length; i++)
            {
                //firmwareFile.BaseStream.Position = i;
                newFirmwareFile.Write(tempFile.ReadByte());

                //Console.Write(firmwareFile.ReadByte() + " ");
            }

            tempFile.Close();
            newFirmwareFile.Close();

            Form.ActiveForm.Enabled = true;
        }

19 Source : Form1.cs
with MIT License
from berryelectronics

private void buttonEditorSave_Click(object sender, EventArgs e)
        {
            int curCategoryIndex = cbCategory.SelectedIndex;
            int curItemIndex = cbEdireplacedem.SelectedIndex;

            BinaryWriter tempFile = new BinaryWriter(File.Open(tempFilePath, FileMode.Open));
            
            int startPosition = 0;

            int[] data = generateNotificationBinaryCode(currentEditorHeight, currentEditorWidth);


            switch (curCategoryIndex)
            {
                case 0: //Notifications
                    startPosition = Convert.ToInt32(extVariable.getNotificationNames(currentVersion)[curItemIndex, 1], 16);
                    break;
                case 1: //Medium Time
                    startPosition = Convert.ToInt32(extVariable.getMediumNumberNames(currentVersion)[curItemIndex, 1], 16);
                    break;
                case 2: //Small Date Letters
                    startPosition = Convert.ToInt32(extVariable.getSmallDateTextAndWidths(currentVersion)[curItemIndex, 2], 16);
                    break;
                case 3: //Huge Numbers
                    startPosition = Convert.ToInt32(extVariable.getHugeNumbers(currentVersion)[curItemIndex, 1], 16);
                    break;
                case 4: //Additional Icons and Animations
                    startPosition = Convert.ToInt32(extVariable.getAdditionalIconsAnimations(currentVersion)[curItemIndex, 2], 16);
                    break;
            }

            tempFile.BaseStream.Position = startPosition;

            for (int i = 0; i < data[1599]; i++)
            {  
                tempFile.Write(Convert.ToByte(data[i]));
            }

            tempFile.Close();
        }

19 Source : Form1.cs
with MIT License
from berryelectronics

private void generateVarialesHugeNumbers()
        {
            var rawIconData = extVariable.getCategories("hugeNumbers");

            var output = "public String[,] " + textBoxVariableName.Text + " = new string[,]\r\n";
            output += "\t\t{\r\n";

            for (int i = 0; i < rawIconData.GetLength(0); i++)
            {
                //Temporary Write Icon Data to file
                var path = Path.GetTempPath();
                var fileName = Guid.NewGuid().ToString() + ".fw";
                var tempfilepath = Path.Combine(path, fileName);
                BinaryWriter tempFile = new BinaryWriter(File.Open(tempfilepath, FileMode.CreateNew));
                tempFile.BaseStream.Position = 0;

                for (int j = 0; j < (rawIconData[i, 1].Length); j += 2)
                {
                    var tempIconByte = Convert.ToByte((rawIconData[i, 1][j].ToString() + rawIconData[i, 1][j + 1].ToString()), 16);
                    tempFile.Write(tempIconByte);
                    //Console.WriteLine((rawIconData[i, 1][j].ToString() + rawIconData[i, 1][j+1].ToString()) + " | " + tempIconByte); // DEBUG
                }

                tempFile.Close();
                //Console.WriteLine(tempfilepath); // DEBUG
                tempFile = null;

                patternFileName = tempfilepath;
                patternLoaded = true;
                labelPatternPath.Text = patternFileName;
                clearText();

                searchPattern_Variables(tempfilepath, firmwareFileName);
                var outputDebug = rawIconData[i, 0].ToString() + " | " + tBStartPosHex.Text.ToString() + " | " + tBEndPosHex.Text.ToString();
                //Console.WriteLine(outputDebug); // DEBUG

                output += "\t\t\t{ \"" + rawIconData[i, 0] + "\", \"" + tBStartPosHex.Text.ToString() + "\", \"" + tBEndPosHex.Text.ToString() + "\"},\r\n";
            }
            output = output.Remove(output.Length - 3) + "\r\n";
            output += "\t\t};";

            textBoxVariablesOutput.Text = output;
        }

19 Source : Form1.cs
with MIT License
from berryelectronics

private void generateVariablesMisc()
        {
            var rawIconData = extVariable.getCategories("miscellaneousIcons");

            var output = "public String[,] " + textBoxVariableName.Text + " = new string[,]\r\n";
            output += "\t\t{\r\n";

            for (int i = 0; i < rawIconData.GetLength(0); i++)
            {
                //Temporary Write Icon Data to file
                var path = Path.GetTempPath();
                var fileName = Guid.NewGuid().ToString() + ".fw";
                var tempfilepath = Path.Combine(path, fileName);
                BinaryWriter tempFile = new BinaryWriter(File.Open(tempfilepath, FileMode.CreateNew));
                tempFile.BaseStream.Position = 0;

                for (int j = 0; j < (rawIconData[i, 3].Length); j += 2)
                {
                    var tempIconByte = Convert.ToByte((rawIconData[i, 3][j].ToString() + rawIconData[i, 3][j + 1].ToString()), 16);
                    tempFile.Write(tempIconByte);
                    //Console.WriteLine((rawIconData[i, 3][j].ToString() + rawIconData[i, 3][j+1].ToString()) + " | " + tempIconByte); // DEBUG
                }

                tempFile.Close();
                //Console.WriteLine(tempfilepath); // DEBUG
                tempFile = null;

                patternFileName = tempfilepath;
                patternLoaded = true;
                labelPatternPath.Text = patternFileName;
                clearText();


                if (rawIconData[i, 4] == "2")
                {
                    searchPattern_Variables(tempfilepath, firmwareFileName, 2);
                }
                else if (rawIconData[i, 4] == "3")
                {
                    searchPattern_Variables(tempfilepath, firmwareFileName, 3);
                }
                else
                {
                    searchPattern_Variables(tempfilepath, firmwareFileName);
                }

                //Check if pattern has been found or not
                var outputDebug = "";
                if (tBStartPosHex.Text.ToString() != "")
                {
                    outputDebug = rawIconData[i, 0].ToString() + " | " + tBStartPosHex.Text.ToString() + " | " + tBEndPosHex.Text.ToString();
                    output += "\t\t\t{ \"" + rawIconData[i, 0] + "\", \"" + rawIconData[i, 1] + "\", \"" + tBStartPosHex.Text.ToString() + "\", \"" + tBEndPosHex.Text.ToString() + "\", \"" + rawIconData[i, 2] + "\"},\r\n";
                }
                else
                {
                    outputDebug = "// " + rawIconData[i, 0].ToString() + " | " + tBStartPosHex.Text.ToString() + " | " + tBEndPosHex.Text.ToString();
                    output += "\t\t\t// { \"" + rawIconData[i, 0] + "\", \"" + rawIconData[i, 1] + "\", \"" + tBStartPosHex.Text.ToString() + "\", \"" + tBEndPosHex.Text.ToString() + "\", \"" + rawIconData[i, 2] + "\"},\r\n";
                }

                //Console.WriteLine(outputDebug); // DEBUG

               
            }
            output = output.Remove(output.Length - 3) + "\r\n";
            output += "\t\t};";

            textBoxVariablesOutput.Text = output;
        }

19 Source : Form1.cs
with MIT License
from berryelectronics

private void buttonFirmwareLoad_Click(object sender, EventArgs e)
        {
            ofd.ShowDialog();

            Form.ActiveForm.Enabled = false;

            BinaryReader firmwareFile = new BinaryReader(File.Open(ofd.FileName, FileMode.Open));
            BinaryWriter tempFile = new BinaryWriter(File.Open(tempFilePath, FileMode.Open));

            firmwareFile.BaseStream.Position = 0;
            tempFile.BaseStream.Position = 0;

            for (int i = 0; i < firmwareFile.BaseStream.Length; i++)
            {
                tempFile.Write(firmwareFile.ReadByte());
            }


            firmwareFile.Close();
            tempFile.Close();

            firmwareLoaded = true;
            Form.ActiveForm.Enabled = true;
            buttonFirmwareSave.Enabled = true;

            //currenreplacedemChanged();
            labelInfoSelectVersion.Visible = true;
        }

19 Source : Form1.cs
with MIT License
from berryelectronics

private void buttonFirmwareLoad_Click(object sender, EventArgs e)
        {
            ofd.ShowDialog();

            Form.ActiveForm.Enabled = false;

            BinaryReader firmwareFile = new BinaryReader(File.Open(ofd.FileName, FileMode.Open));
            BinaryWriter tempFile = new BinaryWriter(File.Open(tempFilePath, FileMode.Open));

            firmwareFile.BaseStream.Position = 0;
            tempFile.BaseStream.Position = 0;

            for (int i = 0; i < firmwareFile.BaseStream.Length; i++)
            {
                tempFile.Write(firmwareFile.ReadByte());
            }


            firmwareFile.Close();
            tempFile.Close();

            firmwareLoaded = true;
            Form.ActiveForm.Enabled = true;
        }

19 Source : B3dm.cs
with MIT License
from bertt

public byte[] ToBytes()
        {
            var header_length = 28;

            var featureTableJson = BufferPadding.AddPadding(FeatureTableJson, header_length);
            var batchTableJson = BufferPadding.AddPadding(BatchTableJson);
            var featureTableBinary = BufferPadding.AddPadding(FeatureTableBinary);
            var batchTableBinary = BufferPadding.AddPadding(BatchTableBinary);

            B3dmHeader.ByteLength = GlbData.Length + header_length + featureTableJson.Length + Encoding.UTF8.GetByteCount(batchTableJson) + batchTableBinary.Length + FeatureTableBinary.Length;

            B3dmHeader.FeatureTableJsonByteLength = featureTableJson.Length;
            B3dmHeader.BatchTableJsonByteLength = Encoding.UTF8.GetByteCount(batchTableJson);
            B3dmHeader.FeatureTableBinaryByteLength =featureTableBinary.Length;
            B3dmHeader.BatchTableBinaryByteLength = batchTableBinary.Length;

            var memoryStream = new MemoryStream();
            var binaryWriter = new BinaryWriter(memoryStream);
            binaryWriter.Write(B3dmHeader.AsBinary());
            binaryWriter.Write(Encoding.UTF8.GetBytes(featureTableJson));
            if (featureTableBinary != null) {
                binaryWriter.Write(featureTableBinary);
            }
            binaryWriter.Write(Encoding.UTF8.GetBytes(batchTableJson));
            if (batchTableBinary != null) {
                binaryWriter.Write(batchTableBinary);
            }
            binaryWriter.Write(GlbData);
            binaryWriter.Flush();
            binaryWriter.Close();
            return memoryStream.ToArray();
        }

19 Source : StorageManager.cs
with zlib License
from blendogames

public void SaveData(SaveInfo infoData)
        {
            if (device == null)
                return;
            try
            {
                using (StorageContainer container = device.OpenContainer(GAMENAME))
                {
                    using (Stream stream = container.OpenFile(SAVEFILE, FileMode.Create))
                    {
                        BinaryWriter writer = new BinaryWriter(stream);

                        writer.Write((Int16)infoData.adventure);
                        writer.Write((Int16)infoData.volume);
                        writer.Write((Int16)infoData.music);
                        writer.Write((Int16)infoData.brightness);

                        for (int i = 0; i < 24; i++)
                        {
                            writer.Write((Int16)infoData.skirmishArray[i]);
                        }

                        writer.Write((bool)infoData.p1InvertY);
                        writer.Write((bool)infoData.p1InvertX);
                        writer.Write((bool)infoData.p1vibration);

                        writer.Write((bool)infoData.p2InvertY);
                        writer.Write((bool)infoData.p2InvertX);
                        writer.Write((bool)infoData.p2vibration);

#if WINDOWS
                    writer.Write((string)infoData.playerName);
#endif

                        writer.Close();
                        stream.Close();
                    }

                    container.Dispose();
                }
            }
            catch
            {
            }
        }

19 Source : StorageManager.cs
with zlib License
from blendogames

public void SaveHighScores(HighScoreEntry infoData)
        {
            if (highScoreDevice == null)
                return;

            try
            {
                using (StorageContainer container = highScoreDevice.OpenContainer(GAMENAME))
                {
                    using (Stream stream = container.OpenFile(SCOREFILE, FileMode.Create))
                    {
                        BinaryWriter writer = new BinaryWriter(stream);

                        writer.Write((Int16)infoData.count);

                        for (int i = 0; i < infoData.count; i++)
                        {
                            writer.Write((string)infoData.commanderName[i]);
                            writer.Write((Int32)infoData.scores[i]);
                        }

                        writer.Close();
                        stream.Close();
                    }

                    container.Dispose();
                }
            }
            catch
            {
            }

            FrameworkCore.highScores = infoData;
        }

19 Source : STMHttpSerializer.cs
with MIT License
from blkcatman

void SaveToBinary(string path, byte[] data) {
			FileStream fs = new FileStream(path, FileMode.OpenOrCreate);
			BinaryWriter bw = new BinaryWriter(fs);
			bw.Write(data);
			bw.Close();
			fs.Close();
		}

19 Source : Vanilla.NetMessage.cs
with MIT License
from blushiemagic

internal static void NetMessage_SendData(On.Terraria.NetMessage.orig_SendData orig, int msgType, int remoteClient, int ignoreClient, NetworkText text, int number, float number2, float number3, float number4, int number5, int number6, int number7)
		{
			//TileSection (10) doesn't set "networkSend" to true in TileEnreplacedy.Write, so this needs to be kept track of manually
			//Keeping track of this simplifies the workaround code somewhat
			EditsLoader.MessageTileEnreplacedySyncing = msgType == MessageID.TileSection;

			orig(msgType, remoteClient, ignoreClient, text, number, number2, number3, number4, number5, number6, number7);

			EditsLoader.MessageTileEnreplacedySyncing = false;

			//Catch any uses of IDs TileSection (10) and send the ModPacket message
			//This is to cirreplacedvent the 65535 shorts' worth of data per-message limit and, hopefully, prevent world sections from suddenly disappearing for no reason
			if (msgType == MessageID.TileSection)
			{
				ModPacket packet = MagicStorage.Instance.GetPacket();

				//Get the enreplacedies in the section.  Keep writing until the next enreplacedy written would make the size go over 65535
				int startX = number;
				int startY = (int)number2;
				short width = (short)number3;
				short height = (short)number4;

				Queue<int> ids = new Queue<int>();

				//Only process tile enreplacedies from Magic Storage
				foreach (var item in TileEnreplacedy.ByPosition) {
					Point16 pos = item.Key;
					if (pos.X >= startX && pos.X < startX + width && pos.Y >= startY && pos.Y < startY + height)
						if (ModTileEnreplacedy.GetTileEnreplacedy(item.Value.type)?.mod == MagicStorage.Instance)
							ids.Enqueue(item.Value.ID);
				}

				MemoryStream ms = new MemoryStream();
				MemoryStream ms2 = new MemoryStream();
				BinaryWriter msWriter = new BinaryWriter(ms);
				BinaryWriter msWriter2 = new BinaryWriter(ms2);
				int written = 0, total = 0, packetCount = 1;

				while(ids.Count > 0)
					WriteNetWorkaround(msWriter, ms, msWriter2, ms2, ids, ref written, ref total, ref packetCount, ref packet, remoteClient, ignoreClient, lastSend: false);

				if(written > 0)
				{
					//Write the remaining information
					WriteNetWorkaround(msWriter, ms, msWriter2, ms2, ids, ref written, ref total, ref packetCount, ref packet, remoteClient, ignoreClient, lastSend: true);
				}

				/*
				if (Main.netMode == NetmodeID.Server && total > 0)
					Console.WriteLine($"Magic Storage: Wrote {packetCount} packets for {total} enreplacedies, {(packetCount - 1) * 65535 + ms.Position} bytes written");
				*/

				msWriter.Flush();
				msWriter.Close();
				msWriter.Dispose();

				msWriter2.Flush();
				msWriter2.Close();
				msWriter2.Dispose();
			}
		}

19 Source : FileServer.cs
with GNU General Public License v2.0
from bmachuletz

void WriteFile(HttpListenerContext ctx, string path)
        {
            var response = ctx.Response;
            using (FileStream fs = File.OpenRead(path))
            {
                string filename = Path.GetFileName(path);
                //response is HttpListenerContext.Response...
                response.ContentLength64 = fs.Length;
                response.SendChunked = false;
                response.ContentType = System.Net.Mime.MediaTypeNames.Application.Octet;
                response.AddHeader("Content-disposition", "attachment; filename=" + filename);

                byte[] buffer = new byte[64 * 1024];
                int read;
                using (BinaryWriter bw = new BinaryWriter(response.OutputStream))
                {
                    while ((read = fs.Read(buffer, 0, buffer.Length)) > 0)
                    {
                        bw.Write(buffer, 0, read);
                        bw.Flush(); //seems to have no effect
                    }

                    bw.Close();
                }

                response.StatusCode = (int)HttpStatusCode.OK;
                response.StatusDescription = "OK";
                response.OutputStream.Close();
            }
        }

19 Source : RiffWriter.cs
with MIT License
from bonsai-rx

protected virtual void Dispose(bool disposing)
        {
            if (!disposed)
            {
                if (disposing)
                {
                    var position = writer.BaseStream.Position;
                    writer.BaseStream.Seek(0, SeekOrigin.Begin);
                    WriteRiffHeader(writer, format, (uint)dataSize);
                    writer.BaseStream.Seek(position, SeekOrigin.Begin);
                    writer.Close();
                    disposed = true;
                }
            }
        }

19 Source : MemberCommunicator.cs
with GNU General Public License v3.0
from bosima

protected override void ProcessRequest(HttpListenerContext context)
        {
            byte[] processResult;

            try
            {
                processResult = OnReceiveWebRequestHandler?.Invoke(context);
                context.Response.StatusCode = 200;
            }
            catch (FileNotFoundException ex)
            {
                context.Response.StatusCode = 404;
                processResult = Encoding.UTF8.GetBytes("{\"ErrCode\":1,\"ErrMsg\":\"" + ex.Message + "\"}");
            }
            catch (DirectoryNotFoundException ex)
            {
                context.Response.StatusCode = 404;
                processResult = Encoding.UTF8.GetBytes("{\"ErrCode\":1,\"ErrMsg\":\"" + ex.Message + "\"}");
            }
            catch (Exception ex)
            {
                context.Response.StatusCode = 500;
                processResult = Encoding.UTF8.GetBytes("{\"ErrCode\":1,\"ErrMsg\":\"" + ex.Message + "\"}");
            }

            HttpListenerRequest request = context.Request;
            using (BinaryWriter writer = new BinaryWriter(context.Response.OutputStream))
            {
                writer.Write(processResult);
                writer.Close();
                context.Response.Close();
            }
        }

See More Examples