System.IO.BinaryWriter.Write(ulong)

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

297 Examples 7

19 Source : FileCacheManager.cs
with Apache License 2.0
from acarteas

protected void HeaderVersionWrite(BinaryWriter writer)
        {
            // Don't much care about exceptions here - let them bubble up.
            writer.Write(CACHE_VERSION);
        }

19 Source : SerializableCacheItemPolicy.cs
with Apache License 2.0
from acarteas

public void Serialize(BinaryWriter writer)
        {
            writer.Write(CACHE_VERSION);

            writer.Write(AbsoluteExpiration.DateTime.ToBinary());
            writer.Write(AbsoluteExpiration.Offset.TotalMilliseconds);

            writer.Write(SlidingExpiration.TotalMilliseconds);

            writer.Write(Key);
        }

19 Source : AllegianceData.cs
with GNU Affero General Public License v3.0
from ACEmulator

public static void Write(this BinaryWriter writer, AllegianceData data)
        {
            // ObjectID - characterID - Character ID
            // uint - cpCached - XP gained while logged off
            // uint - cpreplacedhed - Total allegiance XP contribution
            // uint - bitfield - AllegianceIndex
            // Gender - gender - The gender of the character (for determining replacedle)
            // HeritageGroup - hg - The heritage of the character (for determining replacedle)
            // ushort - rank - The numerical rank (1 is lowest).

            // Choose valid sections by masking against bitfield
            // uint - level

            // ushort - loyalty - Character loyalty
            // ushort - leadership - Character leadership

            // Choose based on testing bitfield == 0x4 (HasAllegianceAge)
            // True:
            // uint - timeOnline
            // uint - allegianceAge
            // False: (Not found in later retail pcaps. Probably deprecated.)
            // ulong - uTimeOnline

            // string - name

            uint characterID = 0;
            uint cpCached = 0;
            uint cpreplacedhed = 0;
            var bitfield = AllegianceIndex.HasAllegianceAge | AllegianceIndex.HasPackedLevel;
            var gender = Gender.Female;
            var hg = HeritageGroup.Aluvian;
            ushort rank = 0;
            uint level = 0;
            ushort loyalty = 0;
            ushort leadership = 0;
            ulong uTimeOnline = 0;
            uint timeOnline = 0;
            uint allegianceAge = 0;
            var name = "";

            if (data.Node != null)
            {
                var node = data.Node;
                var playerGuid = node.PlayerGuid;
                var player = PlayerManager.FindByGuid(playerGuid, out var playerIsOnline);
                
                characterID = player.Guid.Full;
                cpCached = (uint)Math.Min(player.AllegianceXPCached, uint.MaxValue);
                cpreplacedhed = (uint)Math.Min(player.AllegianceXPGenerated, uint.MaxValue);

                if (playerIsOnline)
                    bitfield |= AllegianceIndex.LoggedIn;

                if (!node.IsMonarch && node.Player.ExistedBeforeAllegianceXpChanges)
                    bitfield |= AllegianceIndex.MayPreplacedupExperience;

                gender = (Gender)player.Gender;
                hg = (HeritageGroup)player.Heritage;
                rank = (ushort)node.Rank;
                level = (uint)player.Level;
                loyalty = (ushort)player.GetCurrentLoyalty();
                leadership = (ushort)player.GetCurrentLeadership();
                
                //if (!node.IsMonarch)
                //{
                // TODO: Get/set total time sworn to patron (allegianceAge) and total in-game time since swearing to patron (timeOnline)
                //}

                name = player.Name;
                
            }

            writer.Write(characterID);
            writer.Write(cpCached);
            writer.Write(cpreplacedhed);
            writer.Write((uint)bitfield);
            writer.Write((byte)gender);
            writer.Write((byte)hg);
            writer.Write(rank);

            if (bitfield.HasFlag(AllegianceIndex.HasPackedLevel))
                writer.Write(level);

            writer.Write(loyalty);
            writer.Write(leadership);

            if (bitfield.HasFlag(AllegianceIndex.HasAllegianceAge))
            {
                writer.Write(timeOnline);
                writer.Write(allegianceAge);
            }
            else
                writer.Write(uTimeOnline);

            writer.WriteString16L(name);
        }

19 Source : BasicBlockSerializer.cs
with GNU General Public License v3.0
from Aekras1a

public void WriteData(ILBlock block, BinaryWriter writer)
        {
            uint offset = 0;
            SequencePoint prevSeq = null;
            uint prevOffset = 0;
            foreach(var instr in block.Content)
            {
                if(rt.dbgWriter != null && instr.IR.ILAST is ILASTExpression)
                {
                    var expr = (ILASTExpression) instr.IR.ILAST;
                    var seq = expr.CILInstr == null ? null : expr.CILInstr.SequencePoint;

                    if(seq != null && seq.StartLine != 0xfeefee && (prevSeq == null || !Equals(seq, prevSeq)))
                    {
                        if(prevSeq != null)
                        {
                            uint len = offset - prevOffset, line = (uint) prevSeq.StartLine;
                            var doc = prevSeq.Doreplacedent.Url;

                            rt.dbgWriter.AddSequencePoint(block, prevOffset, len, doc, line);
                        }
                        prevSeq = seq;
                        prevOffset = offset;
                    }
                }

                writer.Write(rt.Descriptor.Architecture.OpCodes[instr.OpCode]);
                // Leave a padding to let BasicBlockChunk fixup block exit key
                writer.Write((byte) rt.Descriptor.Random.Next());
                offset += 2;

                if(instr.Operand != null)
                    if(instr.Operand is ILRegister)
                    {
                        writer.Write(rt.Descriptor.Architecture.Registers[((ILRegister) instr.Operand).Register]);
                        offset++;
                    }
                    else if(instr.Operand is ILImmediate)
                    {
                        var value = ((ILImmediate) instr.Operand).Value;
                        if(value is int)
                        {
                            writer.Write((int) value);
                            offset += 4;
                        }
                        else if(value is uint)
                        {
                            writer.Write((uint) value);
                            offset += 4;
                        }
                        else if(value is long)
                        {
                            writer.Write((long) value);
                            offset += 8;
                        }
                        else if(value is ulong)
                        {
                            writer.Write((ulong) value);
                            offset += 8;
                        }
                        else if(value is float)
                        {
                            writer.Write((float) value);
                            offset += 4;
                        }
                        else if(value is double)
                        {
                            writer.Write((double) value);
                            offset += 8;
                        }
                    }
                    else
                    {
                        throw new NotSupportedException();
                    }
            }

            if(prevSeq != null)
            {
                uint len = offset - prevOffset, line = (uint) prevSeq.StartLine;
                var doc = prevSeq.Doreplacedent.Url;

                rt.dbgWriter.AddSequencePoint(block, prevOffset, len, doc, line);
            }
        }

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 : ForeignRowData.cs
with GNU Affero General Public License v3.0
from aianlinb

public override void Write(BinaryWriter writer) {
			if (Dat.x64) {
				writer.Write(Key1 ?? Nullx64Key);
				writer.Write(Key2 ?? Nullx64Key);
			} else {
				writer.Write((uint?)Key1 ?? Nullx32Key);
				writer.Write((uint?)Key2 ?? Nullx32Key);
			}
		}

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

public override void Write(BinaryWriter writer) {
			if (Dat.x64)
				writer.Write(Key ?? Nullx64Key);
			else
				writer.Write((uint?)Key ?? Nullx32Key);
		}

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

protected virtual void Save(Stream stream, bool x64, bool UTF32) {
			var bw = new BinaryWriter(stream);
			bw.Write(FieldDatas.Count);
			this.x64 = x64;
			this.UTF32 = UTF32;
			CurrentOffset = 8;
			DataSectionOffset = FieldDatas.Count * CalculateRecordLength(FieldDefinitions.Select(t => t.Value), x64) + 4;
			ReferenceDatas.Clear();
			ReferenceDataOffsets.Clear();
			foreach (var fds in FieldDatas)
				foreach (var fd in fds)
					fd.Write(bw);
			bw.Write(0xBBBBBBBBBBBBBBBB); // Magic number
			bw.Seek((int)(DataSectionOffset + CurrentOffset), SeekOrigin.Begin); // Move to the end of dat file
		}

19 Source : UnsignedInt64DataTypeHandler.cs
with MIT License
from aloneguid

protected override void WriteOne(BinaryWriter writer, ulong value)
      {
         writer.Write(value);
      }

19 Source : MinisignPublicKeyDictionary.cs
with GNU General Public License v3.0
from Amebis

public void WriteXml(XmlWriter writer)
        {
            foreach (var el in this)
            {
                writer.WriteStartElement("PublicKey");
                using (var s = new MemoryStream(42))
                {
                    using (var w = new BinaryWriter(s))
                    {
                        w.Write('E');
                        w.Write('d');
                        w.Write(el.Key);
                        w.Write(el.Value);
                    }
                    writer.WriteBase64(s.GetBuffer(), 0, (int)s.Length);
                }
                writer.WriteEndElement();
            }
        }

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

public void rwULong(ref ulong v) { writer.Write(v); }

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

public void wULong(ulong v) { writer.Write(v); }

19 Source : extensions.cs
with Apache License 2.0
from AntonioDePau

public static void Write(this Stream stream, ulong value) => new BinaryWriter(stream).Write(value);

19 Source : BuiltInResourceData.cs
with GNU General Public License v3.0
from anydream

public void WriteData(BinaryWriter writer, IFormatter formatter) {
			switch (code) {
			case ResourceTypeCode.Null:
				break;

			case ResourceTypeCode.String:
				writer.Write((string)data);
				break;

			case ResourceTypeCode.Boolean:
				writer.Write((bool)data);
				break;

			case ResourceTypeCode.Char:
				writer.Write((ushort)(char)data);
				break;

			case ResourceTypeCode.Byte:
				writer.Write((byte)data);
				break;

			case ResourceTypeCode.SByte:
				writer.Write((sbyte)data);
				break;

			case ResourceTypeCode.Int16:
				writer.Write((short)data);
				break;

			case ResourceTypeCode.UInt16:
				writer.Write((ushort)data);
				break;

			case ResourceTypeCode.Int32:
				writer.Write((int)data);
				break;

			case ResourceTypeCode.UInt32:
				writer.Write((uint)data);
				break;

			case ResourceTypeCode.Int64:
				writer.Write((long)data);
				break;

			case ResourceTypeCode.UInt64:
				writer.Write((ulong)data);
				break;

			case ResourceTypeCode.Single:
				writer.Write((float)data);
				break;

			case ResourceTypeCode.Double:
				writer.Write((double)data);
				break;

			case ResourceTypeCode.Decimal:
				writer.Write((decimal)data);
				break;

			case ResourceTypeCode.DateTime:
				writer.Write(((DateTime)data).ToBinary());
				break;

			case ResourceTypeCode.TimeSpan:
				writer.Write(((TimeSpan)data).Ticks);
				break;

			case ResourceTypeCode.ByteArray:
			case ResourceTypeCode.Stream:
				var ary = (byte[])data;
				writer.Write(ary.Length);
				writer.Write(ary);
				break;

			default:
				throw new InvalidOperationException("Unknown resource type code");
			}
		}

19 Source : CustomAttributeWriter.cs
with GNU General Public License v3.0
from anydream

void WriteElem(TypeSig argType, CAArgument value) {
			if (argType == null) {
				helper.Error("Custom attribute: Arg type is null");
				argType = value.Type;
				if (argType == null)
					return;
			}
			if (!recursionCounter.Increment()) {
				helper.Error("Infinite recursion");
				return;
			}

			TypeSig underlyingType;
			ITypeDefOrRef tdr;
			switch (argType.ElementType) {
			case ElementType.Boolean:
				if (!VerifyTypeAndValue(value, ElementType.Boolean))
					writer.Write(ToUInt64(value.Value) != 0);
				else
					writer.Write((bool)value.Value);
				break;

			case ElementType.Char:
				if (!VerifyTypeAndValue(value, ElementType.Char))
					writer.Write((ushort)ToUInt64(value.Value));
				else
					writer.Write((ushort)(char)value.Value);
				break;

			case ElementType.I1:
				if (!VerifyTypeAndValue(value, ElementType.I1))
					writer.Write((sbyte)ToUInt64(value.Value));
				else
					writer.Write((sbyte)value.Value);
				break;

			case ElementType.U1:
				if (!VerifyTypeAndValue(value, ElementType.U1))
					writer.Write((byte)ToUInt64(value.Value));
				else
					writer.Write((byte)value.Value);
				break;

			case ElementType.I2:
				if (!VerifyTypeAndValue(value, ElementType.I2))
					writer.Write((short)ToUInt64(value.Value));
				else
					writer.Write((short)value.Value);
				break;

			case ElementType.U2:
				if (!VerifyTypeAndValue(value, ElementType.U2))
					writer.Write((ushort)ToUInt64(value.Value));
				else
					writer.Write((ushort)value.Value);
				break;

			case ElementType.I4:
				if (!VerifyTypeAndValue(value, ElementType.I4))
					writer.Write((int)ToUInt64(value.Value));
				else
					writer.Write((int)value.Value);
				break;

			case ElementType.U4:
				if (!VerifyTypeAndValue(value, ElementType.U4))
					writer.Write((uint)ToUInt64(value.Value));
				else
					writer.Write((uint)value.Value);
				break;

			case ElementType.I8:
				if (!VerifyTypeAndValue(value, ElementType.I8))
					writer.Write((long)ToUInt64(value.Value));
				else
					writer.Write((long)value.Value);
				break;

			case ElementType.U8:
				if (!VerifyTypeAndValue(value, ElementType.U8))
					writer.Write(ToUInt64(value.Value));
				else
					writer.Write((ulong)value.Value);
				break;

			case ElementType.R4:
				if (!VerifyTypeAndValue(value, ElementType.R4))
					writer.Write((float)ToDouble(value.Value));
				else
					writer.Write((float)value.Value);
				break;

			case ElementType.R8:
				if (!VerifyTypeAndValue(value, ElementType.R8))
					writer.Write(ToDouble(value.Value));
				else
					writer.Write((double)value.Value);
				break;

			case ElementType.String:
				if (VerifyTypeAndValue(value, ElementType.String, typeof(UTF8String)))
					WriteUTF8String((UTF8String)value.Value);
				else if (VerifyTypeAndValue(value, ElementType.String, typeof(string)))
					WriteUTF8String((string)value.Value);
				else
					WriteUTF8String(UTF8String.Empty);
				break;

			case ElementType.ValueType:
				tdr = ((TypeDefOrRefSig)argType).TypeDefOrRef;
				underlyingType = GetEnumUnderlyingType(argType);
				if (underlyingType != null)
					WriteElem(underlyingType, value);
				else if (tdr is TypeRef && TryWriteEnumUnderlyingTypeValue(value.Value)) {
					// No error. replacedume it's an enum that couldn't be resolved.
				}
				else
					helper.Error("Custom attribute value is not an enum");
				break;

			case ElementType.Clreplaced:
				tdr = ((TypeDefOrRefSig)argType).TypeDefOrRef;
				if (CheckCorLibType(argType, "Type")) {
					if (CheckCorLibType(value.Type, "Type")) {
						var ts = value.Value as TypeSig;
						if (ts != null)
							WriteType(ts);
						else if (value.Value == null)
							WriteUTF8String(null);
						else {
							helper.Error("Custom attribute value is not a type");
							WriteUTF8String(UTF8String.Empty);
						}
					}
					else {
						helper.Error("Custom attribute value type is not System.Type");
						WriteUTF8String(UTF8String.Empty);
					}
					break;
				}
				else if (tdr is TypeRef && TryWriteEnumUnderlyingTypeValue(value.Value)) {
					// No error. replacedume it's an enum that couldn't be resolved.
					break;
				}
				goto default;

			case ElementType.SZArray:
				WriteValue(argType, value);
				break;

			case ElementType.Object:
				WriteFieldOrPropType(value.Type);
				WriteElem(value.Type, value);
				break;

			case ElementType.End:
			case ElementType.Void:
			case ElementType.Ptr:
			case ElementType.ByRef:
			case ElementType.Var:
			case ElementType.Array:
			case ElementType.GenericInst:
			case ElementType.TypedByRef:
			case ElementType.ValueArray:
			case ElementType.I:
			case ElementType.U:
			case ElementType.R:
			case ElementType.FnPtr:
			case ElementType.MVar:
			case ElementType.CModReqd:
			case ElementType.CModOpt:
			case ElementType.Internal:
			case ElementType.Module:
			case ElementType.Sentinel:
			case ElementType.Pinned:
			default:
				helper.Error("Invalid or unsupported element type in custom attribute");
				break;
			}

			recursionCounter.Decrement();
		}

19 Source : NativeModuleWriter.cs
with GNU General Public License v3.0
from anydream

static void WriteUInt64(BinaryWriter writer, ulong? value) {
			if (value == null)
				writer.BaseStream.Position += 8;
			else
				writer.Write(value.Value);
		}

19 Source : TablesHeap.cs
with GNU General Public License v3.0
from anydream

public void WriteTo(BinaryWriter writer) {
			writer.Write(options.Reserved1 ?? 0);
			writer.Write(majorVersion);
			writer.Write(minorVersion);
			writer.Write((byte)GetMDStreamFlags());
			writer.Write(GetLog2Rid());
			writer.Write(GetValidMask());
			writer.Write(GetSortedMask());
			foreach (var mdt in Tables) {
				if (!mdt.IsEmpty)
					writer.Write(mdt.Rows);
			}
			if (options.ExtraData.HasValue)
				writer.Write(options.ExtraData.Value);

			writer.Write(ModuleTable);
			writer.Write(TypeRefTable);
			writer.Write(TypeDefTable);
			writer.Write(FieldPtrTable);
			writer.Write(FieldTable);
			writer.Write(MethodPtrTable);
			writer.Write(MethodTable);
			writer.Write(ParamPtrTable);
			writer.Write(ParamTable);
			writer.Write(InterfaceImplTable);
			writer.Write(MemberRefTable);
			writer.Write(ConstantTable);
			writer.Write(CustomAttributeTable);
			writer.Write(FieldMarshalTable);
			writer.Write(DeclSecurityTable);
			writer.Write(ClreplacedLayoutTable);
			writer.Write(FieldLayoutTable);
			writer.Write(StandAloneSigTable);
			writer.Write(EventMapTable);
			writer.Write(EventPtrTable);
			writer.Write(EventTable);
			writer.Write(PropertyMapTable);
			writer.Write(PropertyPtrTable);
			writer.Write(PropertyTable);
			writer.Write(MethodSemanticsTable);
			writer.Write(MethodImplTable);
			writer.Write(ModuleRefTable);
			writer.Write(TypeSpecTable);
			writer.Write(ImplMapTable);
			writer.Write(FieldRVATable);
			writer.Write(ENCLogTable);
			writer.Write(ENCMapTable);
			writer.Write(replacedemblyTable);
			writer.Write(replacedemblyProcessorTable);
			writer.Write(replacedemblyOSTable);
			writer.Write(replacedemblyRefTable);
			writer.Write(replacedemblyRefProcessorTable);
			writer.Write(replacedemblyRefOSTable);
			writer.Write(FileTable);
			writer.Write(ExportedTypeTable);
			writer.Write(ManifestResourceTable);
			writer.Write(NestedClreplacedTable);
			writer.Write(GenericParamTable);
			writer.Write(MethodSpecTable);
			writer.Write(GenericParamConstraintTable);
			writer.WriteZeros((int)(Utils.AlignUp(length, HeapBase.ALIGNMENT) - length));
		}

19 Source : CustomAttributeWriter.cs
with GNU General Public License v3.0
from anydream

bool TryWriteEnumUnderlyingTypeValue(object o) {
			if (o == null)
				return false;
			switch (Type.GetTypeCode(o.GetType())) {
			case TypeCode.Boolean:	writer.Write((bool)o); break;
			case TypeCode.Char:		writer.Write((ushort)(char)o); break;
			case TypeCode.SByte:	writer.Write((sbyte)o); break;
			case TypeCode.Byte:		writer.Write((byte)o); break;
			case TypeCode.Int16:	writer.Write((short)o); break;
			case TypeCode.UInt16:	writer.Write((ushort)o); break;
			case TypeCode.Int32:	writer.Write((int)o); break;
			case TypeCode.UInt32:	writer.Write((uint)o); break;
			case TypeCode.Int64:	writer.Write((long)o); break;
			case TypeCode.UInt64:	writer.Write((ulong)o); break;
			default: return false;
			}
			return true;
		}

19 Source : IChunk.cs
with GNU General Public License v3.0
from anydream

internal static void WriteDataDirectory(this BinaryWriter writer, IChunk chunk) {
			if (chunk == null || chunk.GetVirtualSize() == 0)
				writer.Write(0UL);
			else {
				writer.Write((uint)chunk.RVA);
				writer.Write(chunk.GetVirtualSize());
			}
		}

19 Source : IChunk.cs
with GNU General Public License v3.0
from anydream

internal static void WriteDataDirectory(this BinaryWriter writer, IChunk chunk, uint size) {
			if (chunk == null || chunk.GetVirtualSize() == 0 || size == 0)
				writer.Write(0UL);
			else {
				writer.Write((uint)chunk.RVA);
				writer.Write(size);
			}
		}

19 Source : ImportDirectory.cs
with GNU General Public License v3.0
from anydream

public void WriteTo(BinaryWriter writer) {
			writer.Write((uint)importLookupTableRVA);
			writer.Write(0);	// DateTimeStamp
			writer.Write(0);	// ForwarderChain
			writer.Write((uint)mscoreeDllRVA);	// Name
			writer.Write((uint)ImportAddressTable.RVA);
			writer.Write(0UL);
			writer.Write(0UL);
			writer.Write(0);

			// ImportLookupTable
			writer.Write((uint)corXxxMainRVA);
			writer.Write(0);

			writer.WriteZeros(stringsPadding);
			writer.Write((ushort)0);
			writer.Write(Encoding.UTF8.GetBytes(IsExeFile ? "_CorExeMain\0" : "_CorDllMain\0"));
			writer.Write(Encoding.UTF8.GetBytes("mscoree.dll\0"));

			writer.Write((byte)0);
		}

19 Source : PEHeaders.cs
with GNU General Public License v3.0
from anydream

public void WriteTo(BinaryWriter writer) {
			startOffset = writer.BaseStream.Position;

			// DOS header
			writer.Write(dosHeader);

			// PE magic
			writer.Write(0x00004550);

			// Image file header
			writer.Write((ushort)GetMachine());
			writer.Write((ushort)sections.Count);
			writer.Write(options.TimeDateStamp ?? PEHeadersOptions.CreateNewTimeDateStamp());
			writer.Write(options.PointerToSymbolTable ?? 0);
			writer.Write(options.NumberOfSymbols ?? 0);
			writer.Write((ushort)(Use32BitOptionalHeader() ? 0xE0U : 0xF0));
			writer.Write((ushort)GetCharacteristics());

			var sectionSizes = new SectionSizes(fileAlignment, sectionAlignment, length, () => GetSectionSizeInfos());

			// Image optional header
			uint ep = StartupStub == null ? 0 : (uint)StartupStub.EntryPointRVA;
			if (Use32BitOptionalHeader()) {
				writer.Write((ushort)0x010B);
				writer.Write(options.MajorLinkerVersion ?? PEHeadersOptions.DEFAULT_MAJOR_LINKER_VERSION);
				writer.Write(options.MinorLinkerVersion ?? PEHeadersOptions.DEFAULT_MINOR_LINKER_VERSION);
				writer.Write(sectionSizes.SizeOfCode);
				writer.Write(sectionSizes.SizeOfInitdData);
				writer.Write(sectionSizes.SizeOfUninitdData);
				writer.Write(ep);
				writer.Write(sectionSizes.BaseOfCode);
				writer.Write(sectionSizes.BaseOfData);
				writer.Write((uint)imageBase);
				writer.Write(sectionAlignment);
				writer.Write(fileAlignment);
				writer.Write(options.MajorOperatingSystemVersion ?? 4);
				writer.Write(options.MinorOperatingSystemVersion ?? 0);
				writer.Write(options.MajorImageVersion ?? 0);
				writer.Write(options.MinorImageVersion ?? 0);
				writer.Write(options.MajorSubsystemVersion ?? 4);
				writer.Write(options.MinorSubsystemVersion ?? 0);
				writer.Write(options.Win32VersionValue ?? 0);
				writer.Write(sectionSizes.SizeOfImage);
				writer.Write(sectionSizes.SizeOfHeaders);
				checkSumOffset = writer.BaseStream.Position;
				writer.Write(0);	// CheckSum
				writer.Write((ushort)(options.Subsystem ?? PEHeadersOptions.DEFAULT_SUBSYSTEM));
				writer.Write((ushort)(options.DllCharacteristics ?? PEHeadersOptions.DefaultDllCharacteristics));
				writer.Write((uint)(options.SizeOfStackReserve ?? 0x00100000));
				writer.Write((uint)(options.SizeOfStackCommit ?? 0x00001000));
				writer.Write((uint)(options.SizeOfHeapReserve ?? 0x00100000));
				writer.Write((uint)(options.SizeOfHeapCommit ?? 0x00001000));
				writer.Write(options.LoaderFlags ?? 0x00000000);
				writer.Write(options.NumberOfRvaAndSizes ?? 0x00000010);
			}
			else {
				writer.Write((ushort)0x020B);
				writer.Write(options.MajorLinkerVersion ?? PEHeadersOptions.DEFAULT_MAJOR_LINKER_VERSION);
				writer.Write(options.MinorLinkerVersion ?? PEHeadersOptions.DEFAULT_MINOR_LINKER_VERSION);
				writer.Write(sectionSizes.SizeOfCode);
				writer.Write(sectionSizes.SizeOfInitdData);
				writer.Write(sectionSizes.SizeOfUninitdData);
				writer.Write(ep);
				writer.Write(sectionSizes.BaseOfCode);
				writer.Write(imageBase);
				writer.Write(sectionAlignment);
				writer.Write(fileAlignment);
				writer.Write(options.MajorOperatingSystemVersion ?? 4);
				writer.Write(options.MinorOperatingSystemVersion ?? 0);
				writer.Write(options.MajorImageVersion ?? 0);
				writer.Write(options.MinorImageVersion ?? 0);
				writer.Write(options.MajorSubsystemVersion ?? 4);
				writer.Write(options.MinorSubsystemVersion ?? 0);
				writer.Write(options.Win32VersionValue ?? 0);
				writer.Write(sectionSizes.SizeOfImage);
				writer.Write(sectionSizes.SizeOfHeaders);
				checkSumOffset = writer.BaseStream.Position;
				writer.Write(0);	// CheckSum
				writer.Write((ushort)(options.Subsystem ?? PEHeadersOptions.DEFAULT_SUBSYSTEM));
				writer.Write((ushort)(options.DllCharacteristics ?? PEHeadersOptions.DefaultDllCharacteristics));
				writer.Write(options.SizeOfStackReserve ?? 0x0000000000400000);
				writer.Write(options.SizeOfStackCommit ?? 0x0000000000004000);
				writer.Write(options.SizeOfHeapReserve ?? 0x0000000000100000);
				writer.Write(options.SizeOfHeapCommit ?? 0x0000000000002000);
				writer.Write(options.LoaderFlags ?? 0x00000000);
				writer.Write(options.NumberOfRvaAndSizes ?? 0x00000010);
			}

			writer.WriteDataDirectory(null);	// Export table
			writer.WriteDataDirectory(ImportDirectory);
			writer.WriteDataDirectory(Win32Resources);
			writer.WriteDataDirectory(null);	// Exception table
			writer.WriteDataDirectory(null);	// Certificate table
			writer.WriteDataDirectory(RelocDirectory);
			writer.WriteDataDirectory(DebugDirectory, DebugDirectory.HEADER_SIZE);
			writer.WriteDataDirectory(null);	// Architecture-specific data
			writer.WriteDataDirectory(null);	// Global pointer register RVA
			writer.WriteDataDirectory(null);	// Thread local storage
			writer.WriteDataDirectory(null);	// Load configuration table
			writer.WriteDataDirectory(null);	// Bound import table
			writer.WriteDataDirectory(ImportAddressTable);
			writer.WriteDataDirectory(null);	// Delay import descriptor
			writer.WriteDataDirectory(ImageCor20Header);
			writer.WriteDataDirectory(null);	// Reserved

			// Sections
			uint rva = Utils.AlignUp(sectionSizes.SizeOfHeaders, sectionAlignment);
			foreach (var section in sections)
				rva += section.WriteHeaderTo(writer, fileAlignment, sectionAlignment, rva);
		}

19 Source : ExcelVBASignature.cs
with Apache License 2.0
from Appdynamics

private byte[] GetCertStore()
        {
            var ms = new MemoryStream();
            var bw = new BinaryWriter(ms);

            bw.Write((uint)0); //Version
            bw.Write((uint)0x54524543); //fileType

            //SerializedCertificateEntry
            var certData = Certificate.RawData;
            bw.Write((uint)0x20);
            bw.Write((uint)1);
            bw.Write((uint)certData.Length);
            bw.Write(certData);

            //EndElementMarkerEntry
            bw.Write((uint)0);
            bw.Write((ulong)0);

            bw.Flush();
            return ms.ToArray();
        }

19 Source : Pack_Def_Data.cs
with MIT License
from Arefu

public override void Save(BinaryWriter writer, Localized_Text.Language language)
        {
            const int firstChunkItemSize = 40;
            var fileStartPos = writer.BaseStream.Position;

            writer.Write((ulong) Items.Count);

            var offsetsOffset = writer.BaseStream.Position;
            writer.Write(new byte[Items.Count * firstChunkItemSize]);

            var index = 0;
            foreach (var item in Items.Values)
            {
                var codeNameLen = GetStringSize(item.CodeName.GetText(language), encoding1);
                var nameLen = GetStringSize(item.Name.GetText(language), encoding2);
                var tempOffset = writer.BaseStream.Position;

                writer.BaseStream.Position = offsetsOffset + index * firstChunkItemSize;
                writer.Write(item.Id);
                writer.Write((int) item.Series);
                writer.Write(item.Price);
                writer.Write((int) item.Type);
                writer.WriteOffset(fileStartPos, tempOffset);
                writer.WriteOffset(fileStartPos, tempOffset + codeNameLen);
                writer.WriteOffset(fileStartPos, tempOffset + codeNameLen + nameLen);
                writer.BaseStream.Position = tempOffset;

                writer.WriteNullTerminatedString(item.CodeName.GetText(language), encoding1);
                writer.WriteNullTerminatedString(item.Name.GetText(language), encoding2);
                writer.WriteNullTerminatedString(item.UnkStr.GetText(language), encoding2);

                index++;
            }
        }

19 Source : SKU_Data.cs
with MIT License
from Arefu

public override void Save(BinaryWriter writer, Localized_Text.Language language)
        {
            const int firstChunkItemSize = 24;
            var fileStartPos = writer.BaseStream.Position;

            writer.Write((ulong) Items.Count);

            var offsetsOffset = writer.BaseStream.Position;
            writer.Write(new byte[Items.Count * firstChunkItemSize]);

            var index = 0;
            foreach (var item in Items.Values)
            {
                var keyLen = GetStringSize(item.Key.GetText(language), keyEncoding);
                var tempOffset = writer.BaseStream.Position;

                writer.BaseStream.Position = offsetsOffset + index * firstChunkItemSize;
                writer.Write(item.Id);
                writer.Write((int) item.Series);
                writer.WriteOffset(fileStartPos, tempOffset);
                writer.WriteOffset(fileStartPos, tempOffset + keyLen);
                writer.BaseStream.Position = tempOffset;

                writer.WriteNullTerminatedString(item.Key.GetText(language), keyEncoding);
                writer.WriteNullTerminatedString(item.Value.GetText(language), valueEncoding);

                index++;
            }
        }

19 Source : Arena_Data.cs
with MIT License
from Arefu

public override void Save(BinaryWriter writer, Localized_Text.Language language)
        {
            const int firstChunkItemSize = 28; // Size of each item in the first chunk
            var fileStartPos = writer.BaseStream.Position;

            writer.Write((ulong) Items.Count);

            var offsetsOffset = writer.BaseStream.Position;
            writer.Write(new byte[Items.Count * firstChunkItemSize]);

            var index = 0;
            foreach (var item in Items.Values)
            {
                var keyLen = GetStringSize(item.Key.GetText(language), keyEncoding);
                var valueLen = GetStringSize(item.Value.GetText(language), valueEncoding);
                var tempOffset = writer.BaseStream.Position;

                writer.BaseStream.Position = offsetsOffset + index * firstChunkItemSize;
                writer.Write(item.Id);
                writer.WriteOffset(fileStartPos, tempOffset);
                writer.WriteOffset(fileStartPos, tempOffset + keyLen);
                writer.WriteOffset(fileStartPos, tempOffset + keyLen + valueLen);
                writer.BaseStream.Position = tempOffset;

                writer.WriteNullTerminatedString(item.Key.GetText(language), keyEncoding);
                writer.WriteNullTerminatedString(item.Value.GetText(language), valueEncoding);
                writer.WriteNullTerminatedString(item.Value2.GetText(language), value2Encoding);

                index++;
            }
        }

19 Source : Char_Data.cs
with MIT License
from Arefu

public override void Save(BinaryWriter writer, Localized_Text.Language language)
        {
            const int firstChunkItemSize = 56; // Size of each item in the first chunk
            var fileStartPos = writer.BaseStream.Position;

            writer.Write((ulong) Items.Count);

            var offsetsOffset = writer.BaseStream.Position;
            writer.Write(new byte[Items.Count * firstChunkItemSize]);

            var index = 0;
            foreach (var item in Items.Values)
            {
                var keyLen = GetStringSize(item.CodeName.GetText(language), keyEncoding);
                var valueLen = GetStringSize(item.Name.GetText(language), valueEncoding);
                var tempOffset = writer.BaseStream.Position;

                writer.BaseStream.Position = offsetsOffset + index * firstChunkItemSize;
                writer.Write(item.Id);
                writer.Write((int) item.Series);
                writer.Write(item.ChallengeDeckId);
                writer.Write(item.Unk3);
                writer.Write(item.DlcId);
                writer.Write(item.Unk5);
                writer.Write(item.Type);
                writer.WriteOffset(fileStartPos, tempOffset);
                writer.WriteOffset(fileStartPos, tempOffset + keyLen);
                writer.WriteOffset(fileStartPos, tempOffset + keyLen + valueLen);
                writer.BaseStream.Position = tempOffset;

                writer.WriteNullTerminatedString(item.CodeName.GetText(language), keyEncoding);
                writer.WriteNullTerminatedString(item.Name.GetText(language), valueEncoding);
                writer.WriteNullTerminatedString(item.Bio.GetText(language), descriptionEncoding);

                index++;
            }
        }

19 Source : Deck_Data.cs
with MIT License
from Arefu

public override void Save(BinaryWriter writer, Localized_Text.Language language)
        {
            const int firstChunkItemSize = 56; // Size of each item in the first chunk
            var fileStartPos = writer.BaseStream.Position;

            writer.Write((ulong) Items.Count);

            var offsetsOffset = writer.BaseStream.Position;
            writer.Write(new byte[Items.Count * firstChunkItemSize]);

            var index = 0;
            foreach (var item in Items.Values)
            {
                var deckFileNameLen = GetStringSize(item.DeckFileName.GetText(language), deckFileNameEncoding);
                var deckNameLen = GetStringSize(item.DeckName.GetText(language), deckNameEncoding);
                var deckDescriptionLen = GetStringSize(item.DeckDescription.GetText(language), deckDescriptionEncoding);
                var tempOffset = writer.BaseStream.Position;

                writer.BaseStream.Position = offsetsOffset + index * firstChunkItemSize;
                writer.Write(item.Id1);
                writer.Write(item.Id2);
                writer.Write((int) item.Series);
                writer.Write(item.SignatureCardId);
                writer.Write(item.DeckOwnerId);
                writer.Write(item.Unk1);
                writer.WriteOffset(fileStartPos, tempOffset);
                writer.WriteOffset(fileStartPos, tempOffset + deckFileNameLen);
                writer.WriteOffset(fileStartPos, tempOffset + deckFileNameLen + deckNameLen);
                writer.WriteOffset(fileStartPos, tempOffset + deckFileNameLen + deckNameLen + deckDescriptionLen);
                writer.BaseStream.Position = tempOffset;

                writer.WriteNullTerminatedString(item.DeckFileName.GetText(language), deckFileNameEncoding);
                writer.WriteNullTerminatedString(item.DeckName.GetText(language), deckNameEncoding);
                writer.WriteNullTerminatedString(item.DeckDescription.GetText(language), deckDescriptionEncoding);
                writer.WriteNullTerminatedString(item.UnkStr1.GetText(language), unkStr1Encoding);

                index++;
            }
        }

19 Source : Duel_Data.cs
with MIT License
from Arefu

public override void Save(BinaryWriter writer, Localized_Text.Language language)
        {
            const int firstChunkItemSize = 88;
            var fileStartPos = writer.BaseStream.Position;

            writer.Write((ulong) Items.Count);

            var offsetsOffset = writer.BaseStream.Position;
            writer.Write(new byte[Items.Count * firstChunkItemSize]);

            var index = 0;
            foreach (var item in Items.Values)
            {
                var codeNameLen = GetStringSize(item.CodeName.GetText(language), encoding1);
                var playerAlternateSkinLen = GetStringSize(item.PlayerAlternateSkin.GetText(language), encoding1);
                var opponentAlternateSkinLen = GetStringSize(item.OpponentAlternateSkin.GetText(language), encoding1);
                var nameLen = GetStringSize(item.Name.GetText(language), encoding2);
                var descriptionLen = GetStringSize(item.Description.GetText(language), encoding2);
                var tempOffset = writer.BaseStream.Position;

                writer.BaseStream.Position = offsetsOffset + index * firstChunkItemSize;
                writer.Write(item.Id);
                writer.Write((int) item.Series);
                writer.Write(item.DisplayIndex);
                writer.Write(item.PlayerCharId);
                writer.Write(item.OpponentCharId);
                writer.Write(item.PlayerDeckId);
                writer.Write(item.OpponentDeckId);
                writer.Write(item.ArenaId);
                writer.Write(item.Unk8);
                writer.Write(item.DlcId);
                writer.WriteOffset(fileStartPos, tempOffset);
                writer.WriteOffset(fileStartPos, tempOffset + codeNameLen);
                writer.WriteOffset(fileStartPos, tempOffset + codeNameLen + playerAlternateSkinLen);
                writer.WriteOffset(fileStartPos,
                    tempOffset + codeNameLen + playerAlternateSkinLen + opponentAlternateSkinLen);
                writer.WriteOffset(fileStartPos,
                    tempOffset + codeNameLen + playerAlternateSkinLen + opponentAlternateSkinLen + nameLen);
                writer.WriteOffset(fileStartPos,
                    tempOffset + codeNameLen + playerAlternateSkinLen + opponentAlternateSkinLen + nameLen +
                    descriptionLen);
                writer.BaseStream.Position = tempOffset;

                writer.WriteNullTerminatedString(item.CodeName.GetText(language), encoding1);
                writer.WriteNullTerminatedString(item.PlayerAlternateSkin.GetText(language), encoding1);
                writer.WriteNullTerminatedString(item.OpponentAlternateSkin.GetText(language), encoding1);
                writer.WriteNullTerminatedString(item.Name.GetText(language), encoding2);
                writer.WriteNullTerminatedString(item.Description.GetText(language), encoding2);
                writer.WriteNullTerminatedString(item.Tip.GetText(language), encoding2);

                index++;
            }
        }

19 Source : Serializer.cs
with GNU Lesser General Public License v2.1
from axiom3d

protected void WriteULong(BinaryWriter writer, ulong val)
        {
            writer.Write(val);
        }

19 Source : CompressedHeader.cs
with MIT License
from AyrA

public void WriteHeader(BinaryWriter BW)
        {
            BW.Write(FileTag);
            BW.Write(MaxChunkSize);
            BW.Write(CompressedLength);
            BW.Write(DecompressedLength);
            BW.Write(CompressedLength);
            BW.Write(DecompressedLength);
        }

19 Source : DBReaderExtensions.cs
with The Unlicense
from BAndysc

public static void WriteUInt64(this BinaryWriter bw, ulong value, FieldStructureEntry map = null)
        {
            if (map == null)
                bw.Write(value);
            else
                bw.Write(BitConverter.GetBytes(value), 0, map.ByteCount);
        }

19 Source : BasePacketWriter.cs
with MIT License
from barncastle

public void WriteUInt64(ulong data) => base.Write(data);

19 Source : BaseCharacter.cs
with MIT License
from barncastle

internal void Serialize(BinaryWriter bw)
        {
            bw.Write(Build);
            bw.Write(Clreplaced);
            bw.Write(DisplayId);
            bw.Write(Face);
            bw.Write(FacialHair);
            bw.Write(Gender);
            bw.Write(Guid);
            bw.Write(HairColor);
            bw.Write(HairStyle);
            bw.Write(Location.X);
            bw.Write(Location.Y);
            bw.Write(Location.Z);
            bw.Write(Location.O);
            bw.Write(Location.Map);
            bw.Write(Name);
            bw.Write(PowerType);
            bw.Write(Race);
            bw.Write(Skin);
            bw.Write(Zone);
            bw.Write(Scale);
            bw.Write(IsFlying);
        }

19 Source : BinaryObjectWriter.cs
with MIT License
from BayatGames

public virtual void Write ( object value )
		{
			if ( value == null )
			{
				m_Writer.Write ( 0 );
			}
			else
			{
				Type type = value.GetType ();
				if ( type.IsPrimitive || type == typeof ( string ) || type == typeof ( decimal ) )
				{
					if ( type == typeof ( string ) )
					{
						m_Writer.Write ( ( string )value );
					}
					else if ( type == typeof ( decimal ) )
					{
						m_Writer.Write ( ( decimal )value );
					}
					else if ( type == typeof ( short ) )
					{
						m_Writer.Write ( ( short )value );
					}
					else if ( type == typeof ( int ) )
					{
						m_Writer.Write ( ( int )value );
					}
					else if ( type == typeof ( long ) )
					{
						m_Writer.Write ( ( long )value );
					}
					else if ( type == typeof ( ushort ) )
					{
						m_Writer.Write ( ( ushort )value );
					}
					else if ( type == typeof ( uint ) )
					{
						m_Writer.Write ( ( uint )value );
					}
					else if ( type == typeof ( ulong ) )
					{
						m_Writer.Write ( ( ulong )value );
					}
					else if ( type == typeof ( double ) )
					{
						m_Writer.Write ( ( double )value );
					}
					else if ( type == typeof ( float ) )
					{
						m_Writer.Write ( ( float )value );
					}
					else if ( type == typeof ( byte ) )
					{
						m_Writer.Write ( ( byte )value );
					}
					else if ( type == typeof ( sbyte ) )
					{
						m_Writer.Write ( ( sbyte )value );
					}
					else if ( type == typeof ( char ) )
					{
						m_Writer.Write ( ( char )value );
					}
					else if ( type == typeof ( bool ) )
					{
						m_Writer.Write ( ( bool )value );
					}
				}
				else if ( type.IsEnum )
				{
					m_Writer.Write ( value.ToString () );
				}
				else if ( type == typeof ( DateTime ) )
				{
					m_Writer.Write ( ( ( DateTime )value ).ToBinary () );
				}
				else if ( type == typeof ( TimeSpan ) )
				{
					m_Writer.Write ( ( ( TimeSpan )value ).ToString () );
				}
				else if ( value is ISerializable )
				{
					SerializationInfo info = new SerializationInfo ( type, new FormatterConverter () );
					ISerializable serializable = value as ISerializable;
					serializable.GetObjectData ( info, m_Context );
					WriteSerializationInfo ( info );
				}
				else if ( type.IsSerializable && !type.IsArray )
				{
					WriteObject ( value, type );
				}
				else if ( type.IsArray )
				{
					Array array = value as Array;
					m_Writer.Write ( array.Rank );
					for ( int i = 0; i < array.Rank; i++ )
					{
						m_Writer.Write ( array.GetLength ( i ) );
					}
					int [] indices = new int[array.Rank];
					for ( int i = 0; i < array.Rank; i++ )
					{
						for ( int j = 0; j < array.GetLength ( i ); j++ )
						{
							indices [ i ] = j;
							Write ( array.GetValue ( indices ) );
						}
					}
				}
				else if ( value is IEnumerable && value is ICollection )
				{
					IEnumerable enumerable = value as IEnumerable;
					ICollection collection = value as ICollection;
					IEnumerator e = enumerable.GetEnumerator ();
					m_Writer.Write ( collection.Count );
					while ( e.MoveNext () )
					{
						Write ( e.Current );
					}
				}
				else if ( type.IsGenericType && type.GetGenericTypeDefinition () == typeof ( KeyValuePair<,> ) )
				{
					Write ( type.GetProperty ( "Key" ).GetValue ( value, BindingFlags.Default, null, null, null ) );
					Write ( type.GetProperty ( "Value" ).GetValue ( value, BindingFlags.Default, null, null, null ) );
				}
				else
				{
					ISerializationSurrogate surrogate = null;
					if ( m_SurrogateSelector != null )
					{
						ISurrogateSelector selector;
						surrogate = m_SurrogateSelector.GetSurrogate ( type, m_Context, out selector );
						if ( surrogate != null )
						{
							SerializationInfo info = new SerializationInfo ( type, new FormatterConverter () );
							surrogate.GetObjectData ( value, info, m_Context );
							WriteSerializationInfo ( info );
						}
					}
					if ( surrogate == null )
					{
						WriteObject ( value, type );
					}
				}
			}
		}

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 : MetadataProgramData.cs
with MIT License
from bmresearch

public static byte[] EncodeCreateMasterEdition( ulong? maxSupply )
        {
            var buffer = new MemoryStream();
            BinaryWriter writer = new BinaryWriter(buffer);

            writer.Write((byte)MetadataProgramInstructions.Values.CreateMasterEdition);

            if ( maxSupply == null ){
                writer.Write(new byte[] { 0 }); //Option<>
            } else {
                writer.Write((byte)1); //Option<u64>
                writer.Write((ulong) maxSupply);
            }

            //PrintByteArray(buffer.ToArray());

            return buffer.ToArray();
        }

19 Source : MetadataProgramData.cs
with MIT License
from bmresearch

public static byte[] EncodeMintNewEditionFromMasterEditionViaToken ( ulong edition ) //u64
        {
            var buffer = new MemoryStream();
            BinaryWriter writer = new BinaryWriter(buffer);

            writer.Write((byte)MetadataProgramInstructions.Values.MintNewEditionFromMasterEditionViaToken);
            writer.Write(edition);

            return buffer.ToArray();
        }

19 Source : VaultProgramData.cs
with MIT License
from bmresearch

internal static byte[] EncodeAddTokenToInactiveVault( UInt64 amount )
        {
            var buffer = new MemoryStream();
            BinaryWriter writer = new BinaryWriter(buffer);

            writer.Write( (byte) VaultProgramInstructions.Values.AddTokenToInactiveVault );
            writer.Write( amount );

            return buffer.ToArray();
        }

19 Source : SilverlightSerializer.cs
with MIT License
from CalciumFramework

private static void WriteValue(BinaryWriter writer, object value)
		{
			if (value is string)
				writer.Write((string)value);
			else if (value == null)
				writer.Write("~~NULL~~");
			else if (value is decimal)
			{
				int[] array = Decimal.GetBits((Decimal)value);
				SerializeObject(array, writer, typeof(int[]));
			}
			else if (value is float)
				writer.Write((float)value);
			else if (value is bool)
				writer.Write((bool)value
								 ? 'Y'
								 : 'N');
			else if (value is Guid)
				writer.Write(value.ToString());
			else if (value is DateTime)
				writer.Write(((DateTime)value).Ticks);
			else if (value is TimeSpan)
				writer.Write(((TimeSpan)value).Ticks);
			else if (value is char)
				writer.Write((char)value);
			else if (value is ushort)
				writer.Write((ushort)value);
			else if (value is double)
				writer.Write((double)value);
			else if (value is ulong)
				writer.Write((ulong)value);
			else if (value is int)
				writer.Write((int)value);
			else if (value is uint)
				writer.Write((uint)value);
			else if (value is byte)
				writer.Write((byte)value);
			else if (value is long)
				writer.Write((long)value);
			else if (value is short)
				writer.Write((short)value);
			else if (value is sbyte)
				writer.Write((sbyte)value);
			else
				writer.Write((int)value);
		}

19 Source : BinaryStreamWriter.cs
with MIT License
from CatLib

public void WriteUInt64 (ulong value)
		{
			Write (value);
		}

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

public override void Write(ulong val)
        {
            unchecked
            {
                if (bigEndian) base.Write(ReverseLong(val));
                else base.Write(val);
            }
        }

19 Source : NetWrokWinValue2IfTableStructs.cs
with MIT License
from chatop2020

public static void WriteArray(BinaryWriter writer, ulong[] arr)
        {
            for (int i = 0; i < arr.Length; i++)
            {
                writer.Write(arr[i]);
            }
        }

19 Source : BinaryUInt64Serializer.cs
with MIT License
from CityOfZion

public int Serialize(IBinarySerializer serializer, BinaryWriter writer, object value, BinarySerializerSettings settings = null)
        {
            writer.Write((ulong)value);
            return 8;
        }

19 Source : RicohRP2C0X.cs
with MIT License
from colinvella

public void SaveState(BinaryWriter binaryWriter)
        {
            binaryWriter.Write(Cycle);
            binaryWriter.Write(ScanLine);

            binaryWriter.Write(paletteData);
            binaryWriter.Write(nameTableData);
            binaryWriter.Write(oamData);

            binaryWriter.Write(vramAddress);
            binaryWriter.Write(tempAddress);
            binaryWriter.Write((byte)writeToggle);
            binaryWriter.Write(registerLatch);

            binaryWriter.Write(scrollX);

            binaryWriter.Write(evenFrame);

            binaryWriter.Write(nmiOccurred);
            binaryWriter.Write(nmiOutput);
            binaryWriter.Write(nmiPrevious);
            binaryWriter.Write(nmiDelay);

            binaryWriter.Write(nameTableByte);
            binaryWriter.Write(attributeTableByte);
            binaryWriter.Write(lowTileByte);
            binaryWriter.Write(highTileByte);
            binaryWriter.Write(tileData);

            binaryWriter.Write(sprites.Count);
            foreach (Sprite sprite in sprites)
                sprite.SaveState(binaryWriter);

            binaryWriter.Write(nameTable);
            binaryWriter.Write((byte)vramIncrement);
            binaryWriter.Write(spritePatternTable);
            binaryWriter.Write(backgroundPatternTableAddress);
            binaryWriter.Write((byte)spriteSize);
            binaryWriter.Write(masterSlave);

            binaryWriter.Write(showLeftBackground);
            binaryWriter.Write(showLeftSprites);
            binaryWriter.Write(ShowBackground);
            binaryWriter.Write(ShowSprites);

            binaryWriter.Write(grayscale);
            binaryWriter.Write(tint);

            binaryWriter.Write(spriteZeroHit);
            binaryWriter.Write(spriteOverflow);

	        binaryWriter.Write(oamAddress);
	        binaryWriter.Write(bufferedData);

            Memory.SaveState(binaryWriter);
        }

19 Source : Apu.cs
with MIT License
from colinvella

public void SaveState(BinaryWriter binaryWriter)
        {
            binaryWriter.Write(cycle);
            binaryWriter.Write(framePeriod);
            binaryWriter.Write(frameValue);
            binaryWriter.Write(frameIrq);

            Pulse1.SaveState(binaryWriter);
            Pulse2.SaveState(binaryWriter);
            Triangle.SaveState(binaryWriter);
            Noise.SaveState(binaryWriter);
            Dmc.SaveState(binaryWriter);
        }

19 Source : ObjectReaderWriter.cs
with MIT License
from CyAScott

public static void Write(this BinaryWriter writer, Type valueType, object value, IResolveProxyIds resolver, bool writeHeader = true)
        {
            if (value == null)
            {
                writer.WriteNull();
                return;
            }

            if (typeof(Type).IsreplacedignableFrom(valueType))
            {
                writer.Write((Type)value);
                return;
            }

            if (valueType.IsArray)
            {
                writer.Write(valueType, (Array)value, resolver, writeHeader);
                return;
            }

            if (valueType.IsEnum)
            {
                writer.WriteEnum(valueType, value, writeHeader);
                return;
            }

            if (valueType.IsClreplaced &&
                !valueType.IsSealed &&
                resolver.TryToGetInstanceId(value, out var id))
            {
                if (writeHeader)
                {
                    writer.Write((byte)ObjectType.Proxy);
                }
                writer.Write(id);
                return;
            }

            if (valueType == typeof(DateTime) || valueType == typeof(DateTime?))
            {
                writer.Write((DateTime)value, writeHeader);
                return;
            }

            if (valueType == typeof(Guid) || valueType == typeof(Guid?))
            {
                writer.Write((Guid)value, writeHeader);
                return;
            }

            if (valueType == typeof(TimeSpan) || valueType == typeof(TimeSpan?))
            {
                writer.Write((TimeSpan)value, writeHeader);
                return;
            }

            if (valueType == typeof(bool) || valueType == typeof(bool?))
            {
                if (writeHeader)
                {
                    writer.Write((byte)ObjectType.Boolean);
                }
                writer.Write((bool)value);
                return;
            }

            if (valueType == typeof(byte) || valueType == typeof(byte?))
            {
                if (writeHeader)
                {
                    writer.Write((byte)ObjectType.Byte);
                }
                writer.Write((byte)value);
                return;
            }

            if (valueType == typeof(byte[]))
            {
                if (writeHeader)
                {
                    writer.Write((byte)ObjectType.Bytes);
                }
                var valueBytes = (byte[])value;
                writer.Write(valueBytes.Length);
                writer.BaseStream.Write(valueBytes, 0, valueBytes.Length);
                return;
            }

            if (valueType == typeof(char) || valueType == typeof(char?))
            {
                if (writeHeader)
                {
                    writer.Write((byte)ObjectType.Char);
                }
                writer.Write((char)value);
                return;
            }

            if (valueType == typeof(decimal) || valueType == typeof(decimal?))
            {
                if (writeHeader)
                {
                    writer.Write((byte)ObjectType.Decimal);
                }
                writer.Write((decimal)value);
                return;
            }

            if (valueType == typeof(double) || valueType == typeof(double?))
            {
                if (writeHeader)
                {
                    writer.Write((byte)ObjectType.Double);
                }
                writer.Write((double)value);
                return;
            }

            if (valueType == typeof(float) || valueType == typeof(float?))
            {
                if (writeHeader)
                {
                    writer.Write((byte)ObjectType.Float);
                }
                writer.Write((float)value);
                return;
            }

            if (valueType == typeof(int) || valueType == typeof(int?))
            {
                if (writeHeader)
                {
                    writer.Write((byte)ObjectType.Int);
                }
                writer.Write((int)value);
                return;
            }

            if (valueType == typeof(long) || valueType == typeof(long?))
            {
                if (writeHeader)
                {
                    writer.Write((byte)ObjectType.Long);
                }
                writer.Write((long)value);
                return;
            }

            if (valueType == typeof(sbyte) || valueType == typeof(sbyte?))
            {
                if (writeHeader)
                {
                    writer.Write((byte)ObjectType.SByte);
                }
                writer.Write((sbyte)value);
                return;
            }

            if (valueType == typeof(short) || valueType == typeof(short?))
            {
                if (writeHeader)
                {
                    writer.Write((byte)ObjectType.Short);
                }
                writer.Write((short)value);
                return;
            }

            if (valueType == typeof(string))
            {
                if (writeHeader)
                {
                    writer.Write((byte)ObjectType.Str);
                }
                writer.Write((string)value);
                return;
            }

            if (valueType == typeof(uint) || valueType == typeof(uint?))
            {
                if (writeHeader)
                {
                    writer.Write((byte)ObjectType.UInt);
                }
                writer.Write((uint)value);
                return;
            }

            if (valueType == typeof(ulong) || valueType == typeof(ulong?))
            {
                if (writeHeader)
                {
                    writer.Write((byte)ObjectType.ULong);
                }
                writer.Write((ulong)value);
                return;
            }

            if (valueType == typeof(ushort) || valueType == typeof(ushort?))
            {
                if (writeHeader)
                {
                    writer.Write((byte)ObjectType.UShort);
                }
                writer.Write((ushort)value);
                return;
            }

            if (valueType.IsSerializable)
            {
                writer.WriteSerializable(resolver, valueType, value, writeHeader);
                return;
            }

            throw new ArgumentException($"Unable serialize: {value.GetType()}");
        }

19 Source : EnumReaderWriter.cs
with MIT License
from CyAScott

public static void WriteEnum(this BinaryWriter writer, Type type, object value, bool writeHeader = true)
        {
            if (writeHeader)
            {
                writer.Write((byte)ObjectType.Enum);
                writer.Write(type, false);
            }

            //this gets the .Net integral primitive type behind the enum (ie byte, int, etc.)
            var integralType = Enum.GetUnderlyingType(type);

            if (integralType == typeof(int))
            {
                writer.Write((int)value);
            }
            else if (integralType == typeof(byte))
            {
                writer.Write((byte)value);
            }
            else if (integralType == typeof(uint))
            {
                writer.Write((uint)value);
            }
            else if (integralType == typeof(long))
            {
                writer.Write((long)value);
            }
            else if (integralType == typeof(ulong))
            {
                writer.Write((ulong)value);
            }
            else if (integralType == typeof(sbyte))
            {
                writer.Write((sbyte)value);
            }
            else if (integralType == typeof(short))
            {
                writer.Write((short)value);
            }
            else if (integralType == typeof(ushort))
            {
                writer.Write((ushort)value);
            }
            else
            {
                //this should not be possible based on the limitations of the enum type
                throw new InvalidOperationException("Unable to serialize the enum value.");
            }
        }

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

public void WriteUInt64(ulong data)
        {
            FlushBits();
            writeStream.Write(data);
        }

19 Source : CacheManager.cs
with MIT License
from daeken

static bool TryCacheToDisk() {
			if(NeedCacheToDisk.Count == 0) return false;

			while(NeedCacheToDisk.TryDequeue(out var block)) {
				CacheWriter.Write(block.Addr);
				CacheWriter.Write((ulong) block.ObjectCode.Length);
				CacheWriter.Write(block.ObjectCode);
			}
			CacheWriter.Flush();
			
			return true;
		}

See More Examples