public void GetBufferTest()
 {
     var binarySerializer = new BinarySerializer();
     var buffer = binarySerializer.GetBuffer(new TestHelpers.Customer(21));
     var customer = binarySerializer.Deserializer(buffer, typeof(Customer));
     Assert.IsInstanceOfType(customer, typeof(Customer));
 }

            void IDataSerializable.Serialize(BinarySerializer serializer)
            {
                if (serializer.Mode == SerializerMode.Write)
                {
                    serializer.Writer.Write(Textures.Count);
                    foreach (var texture in Textures)
                    {
                        var name = texture.Key;
                        var list = texture.Value;
                        serializer.Serialize(ref name);
                        serializer.Serialize(ref list);
                    }
                }
                else
                {
                    var count = serializer.Reader.ReadInt32();
                    Textures = new Dictionary<string, List<MaterialTexture>>(count);
                    for(int i = 0; i < count; i++)
                    {
                        string name = null;
                        List<MaterialTexture> list = null;
                        serializer.Serialize(ref name);
                        serializer.Serialize(ref list);
                        Textures.Add(name, list);
                    }
                }

                serializer.Serialize(ref Properties);
            }

 public void GetBuffer_UseGeneric()
 {
     var binarySerializer = new BinarySerializer();
     var buffer = binarySerializer.GetBuffer(new TestHelpers.Customer(32));
     var customer = binarySerializer.Deserializer<Customer>(buffer);
     Assert.IsInstanceOfType(customer, typeof(Customer));
 }

 /// <inheritdoc/>
 void IDataSerializable.Serialize(BinarySerializer serializer)
 {
     serializer.Serialize(ref Name);
     serializer.Serialize(ref ShareConstantBuffers);
     serializer.Serialize(ref Techniques);
     serializer.Serialize(ref Arguments, SerializeFlags.Nullable);
 }

        private void LoadState()
        {
            try
            {
                var ser = new BinarySerializer();
                var stat = ser.Deserialize(StateFileName) as Dictionary<String, Object>;

                if (stat != null)
                {
                    var w = (Int32)stat["Width"];
                    var h = (Int32)stat["Height"];

                    if (w > MinimumSize.Width)
                        Width = w;

                    if (h > MinimumSize.Height)
                        Height = h;

                    var x = (Int32)stat["X"];
                    var y = (Int32)stat["Y"];

                    if (x > 0 && y > 0)
                        Location = new Point(x, y);

                    foreach (var p in GetType().GetProperties())
                    {
                        if (Attribute.IsDefined(p, typeof(StateItemAttribute)))
                            p.SetValue(this, stat[p.Name], null);
                    }
                }
            }
            catch { }
        }

 /// <summary>Reads or writes datas from/to the given binary serializer.</summary>
 /// <param name="serializer">The binary serializer.</param>
 void IDataSerializable.Serialize(BinarySerializer serializer)
 {
     serializer.Serialize(ref MaterialIndex);
     serializer.Serialize(ref IndexBufferRange);
     serializer.Serialize(ref VertexBufferRange);
     serializer.Serialize(ref Properties);
 }

 public DocumentCategorizerComponent(string modelFileName)
     : base(typeof(DocumentCategorizerComponent))
 {
     mBlockSelector = "TextBlock";
     BinarySerializer reader = new BinarySerializer(modelFileName, FileMode.Open);
     LoadModel(reader);
 }

 public void Load(BinarySerializer reader)
 {
     TotalHits = reader.ReadLong();
     ActualSize = reader.ReadInt();
     ResultSetXml = reader.ReadString();
     TimeStamp = DateTime.FromOADate(reader.ReadDouble());
 }

        public void SerializeTest()
        {
            BinarySerializer serializer = new BinarySerializer();
            MemoryStream stream = serializer.Serialize(new List<string>() { "f", "s" });

            Assert.IsNotNull(stream);
        }

        private static void Main(string[] args)
        {
            var file = args[0];

            using (var stream = new FileStream(file, FileMode.Open, FileAccess.Read))
            {
                var serializer = new BinarySerializer();
                serializer.MemberDeserialized += (sender, eventArgs) => Console.WriteLine(eventArgs.MemberName + " : " + eventArgs.Value);

                var iso = serializer.Deserialize<Iso9660.Iso9660>(stream);
                stream.Position = 0;

                var xmlSerializer = new XmlSerializer(typeof (Iso9660.Iso9660));

                var outfilePath = Path.GetDirectoryName(file);
                var outfileName = Path.GetFileNameWithoutExtension(file) + ".xml";
                var outfile = Path.Combine(outfilePath, outfileName);

                using (var xmlStream = new FileStream(outfile, FileMode.Create, FileAccess.Write))
                {
                    xmlSerializer.Serialize(xmlStream, iso);
                }

                Console.ReadKey();
            }
        }

 // *** ISerializable interface implementation ***
 public void Save(BinarySerializer writer)
 {
     writer.WriteLong(TotalHits);
     writer.WriteInt(ActualSize);
     writer.WriteString(ResultSetXml);
     writer.WriteDouble(TimeStamp.ToOADate());
 }

 public void Load(BinarySerializer reader)
 {
     Utils.ThrowException(reader == null ? new ArgumentNullException("reader") : null);
     // the following statements throw serialization-related exceptions
     mLanguage = (Language)reader.ReadInt();
     CreateStemmer();
 }

        public void SerializeAndReadBack()
        {
            var registry = new DependencyFingerprintProtocolRegistry();
            registry.Register<CombinedFingerprintProtocol>();
            registry.Register<SourceSetFingerprintProtocol>();

            var ser = new BinarySerializer(registry);
            var dep = CreateDependencyObject();
            var fp1 = dep.Fingerprint;

            byte[] data;
            using (var ms = new MemoryStream())
            {
                fp1.Save(ser, ms);
                data = ms.ToArray();
            }

            CombinedFingerprint fp2;
            using (var ms = new MemoryStream(data))
            {
                fp2 = new CombinedFingerprint(ser, ms);
            }

            fp1.Should().Be(fp2);
        }

            /// <inheritdoc/>
            void IDataSerializable.Serialize(BinarySerializer serializer)
            {
                serializer.Serialize(ref Name, SerializeFlags.Nullable);

                serializer.Serialize(ref IsSubPass);
                serializer.Serialize(ref Attributes);
                serializer.Serialize(ref Pipeline);
            }

        public override ISerializer ApplyInternal()
        {
            var serializer = new BinarySerializer(_binaryFormatter);

            VerifyErrors(serializer);

            return serializer;
        }

 public void Serialize(BinarySerializer serializer)
 {
     serializer.Serialize(ref Index);
     serializer.Serialize(ref ParentBoneIndex);
     serializer.Serialize(ref Name, false, SerializeFlags.Nullable);
     serializer.Serialize(ref MeshParts);
     serializer.Serialize(ref Attributes);
 }

 void IDataSerializable.Serialize(BinarySerializer serializer)
 {
     serializer.Serialize(ref Character);
     serializer.Serialize(ref Subrect);
     serializer.Serialize(ref Offset);
     serializer.Serialize(ref XAdvance);
     serializer.Serialize(ref BitmapIndex);
 }

 void IDataSerializable.Serialize(BinarySerializer serializer)
 {
     serializer.Serialize(ref FilePath);
     serializer.Serialize(ref DependencyFilePath);
     serializer.SerializeEnum(ref CompilerFlags);
     serializer.Serialize(ref Macros, SerializeFlags.Nullable);
     serializer.Serialize(ref IncludeDirectoryList, serializer.Serialize, SerializeFlags.Nullable);
 }

 void IDataSerializable.Serialize(BinarySerializer serializer)
 {
     serializer.Serialize(ref Index);
     serializer.Serialize(ref ParentIndex);
     serializer.Serialize(ref Transform);
     serializer.Serialize(ref Name, false, SerializeFlags.Nullable);
     serializer.Serialize(ref Children, serializer.Serialize, SerializeFlags.Nullable);
 }

        public void Should_throw_exception_if_msg_is_null()
        {
            // Arrange
            var serializer = new BinarySerializer();


            // Action
            var str = serializer.Serialize<Customer>(null);
        }