public override object ReadDirect(CompactBinaryReader reader, object graph)
 {
     Decimal[] array = (Decimal[])graph;
     for (int i = 0; i < array.Length; i++)
         array[i] = (decimal)CompactBinaryFormatter.Deserialize(reader, reader.CacheContext, false);
     return array;
 }

 public override void SkipDirect(CompactBinaryReader reader, object graph)
 {
     int length = reader.ReadInt32();
     IList list = (IList)graph;
     for (int i = 0; i < length; i++)
         reader.SkipObject();
 }

 public override object Deserialize(Stream inputStream)
 {
     Initialize();
     var input = new InputStream(inputStream);
     var reader = new CompactBinaryReader<InputStream>(input);
     return _deserializerStream.Deserialize(reader);
 }

        static void Main()
        {
            // The Example type internally uses instances generic schemas Generic1 and Generic2
            var src = new Example
            {
                Field = { Field = new Generic2<int> { Field = 13 } }
            };

            // We can also instantiate generic schema in the C# program
            var src1 = new Generic1<Example> { Field = src };
            var src2 = new Generic2<double> {Field = 3.14};

            var output = new OutputBuffer();
            var writer = new CompactBinaryWriter<OutputBuffer>(output);

            Serialize.To(writer, src);
            Serialize.To(writer, src1);
            Serialize.To(writer, src2);

            var input = new InputBuffer(output.Data);
            var reader = new CompactBinaryReader<InputBuffer>(input);

            var dst = Deserialize<Example>.From(reader);
            Debug.Assert(Comparer.Equal(src, dst));

            var dst1 = Deserialize<Generic1<Example>>.From(reader);
            Debug.Assert(Comparer.Equal(src1, dst1));

            var dst2 = Deserialize<Generic2<double>>.From(reader);
            Debug.Assert(Comparer.Equal(src2, dst2));
        }

 public override void Skip(CompactBinaryReader reader)
 {
     // Find an appropriate surrogate by handle
     short handle = reader.ReadInt16();
     ISerializationSurrogate typeSurr = TypeSurrogateSelector.GetSurrogateForTypeHandle(handle, reader.Context.CacheContext);
     typeSurr.Skip(reader);
 }

 public override object ReadDirect(CompactBinaryReader reader, object graph)
 {
     Int32[] array = (Int32[])graph;
     for (int i = 0; i < array.Length; i++)
         array[i] = reader.ReadInt32();
     return array;
 }

 public override object ReadDirect(CompactBinaryReader reader, object graph)
 {
     Array array = (Array)graph;
     for (int i = 0; i < array.Length; i++)
         array.SetValue(reader.ReadObject(), i);
     return array;
 }

 public override object Deserialize(Stream stream)
 {
     var input = new InputStream(stream);
     var reader = new CompactBinaryReader<InputStream>(input);
     return Bond.Deserialize<object>.From(reader);
     //return _deserializer.Deserialize(reader);
 }

        public override void SkipDirect(CompactBinaryReader reader, object graph)
        {
            Array array = (Array)graph;

            for (int i = 0; i < array.Length; i++)
                reader.SkipObject();
        }

 public override object Read(CompactBinaryReader reader)
 {
     int length = reader.ReadInt32();
     byte[] stream = new byte[length];
     stream = reader.ReadBytes(length);
     return UTF8Encoding.UTF8.GetString(stream);
     //return reader.ReadString();
 }

        public override object Read(CompactBinaryReader reader)
        {
            // Find an appropriate surrogate by handle
            short handle = reader.ReadInt16();
            ISerializationSurrogate typeSurr = TypeSurrogateSelector.GetSurrogateForTypeHandle(handle,reader.Context.CacheContext);

            return Enum.ToObject(ActualType, typeSurr.Read(reader));
        }

 public override object ReadDirect(CompactBinaryReader reader, object graph)
 {
     int length = reader.ReadInt32();
     IList list = (IList)graph;
     for (int i = 0; i < length; i++)
         list.Add(reader.ReadObject());
     return list;
 }

 public override void SkipDirect(CompactBinaryReader reader, object graph)
 {
     object[] array = (object[])graph;
     short handle = reader.ReadInt16();
     ISerializationSurrogate surrogate = TypeSurrogateSelector.GetSurrogateForTypeHandle(handle, reader.CacheContext);
     for (int i = 0; i < array.Length; i++)
         reader.SkipObject();
 }

        public override object Read(CompactBinaryReader reader) 
        {
            ISerializationSurrogate decimalSurrogate = TypeSurrogateSelector.GetSurrogateForType(typeof(decimal), null);

            AverageResult result = new AverageResult();
            result.Sum = (decimal)decimalSurrogate.Read(reader);
            result.Count = (decimal)decimalSurrogate.Read(reader);
            return result;
        }

		/// <summary>
		/// Uses a <see cref="BinaryFormatter"/> to read an object of 
		/// type <see cref="ActualType"/> from the underlying stream.
		/// </summary>
		/// <param name="reader">stream reader</param>
		/// <returns>object read from the stream reader</returns>
		public override object Read(CompactBinaryReader reader)
		{
			object result = formatter.Deserialize(reader.BaseStream);
			if (result != null)
			{
				Serializer.AlertLegacySerialization(result.GetType());
			}
			return result;
		}

 /// <summary>
 /// Non default object construction. The idea is to circumvent constructor calls
 /// and populate the object in <see cref="ICompactSerializable.Deserialize"/> method.
 /// </summary>
 /// <returns></returns>
 public override object Instantiate(CompactBinaryReader reader)
 {
     object obj = null;
     if(reader.Context.MemManager != null)
         obj = GetInstance(reader.Context.MemManager);
     if(obj == null)
         obj = FormatterServices.GetUninitializedObject(ActualType);
     return obj;
 }

 public override void SkipDirect(CompactBinaryReader reader, object graph)
 {
     int length = reader.ReadInt32();
     IDictionary dict = (IDictionary)graph;
     for (int i = 0; i < length; i++)
     {
         reader.SkipObject();
         reader.SkipObject();
     }
 }

 public override void Skip(CompactBinaryReader reader)
 {
     int cookie = reader.ReadInt32();
     object custom = reader.Context.GetObject(cookie);
     if (custom == null)
     {
         custom = SessionStateItemCollection.Deserialize(reader.BaseReader);
         reader.Context.RememberObject(custom,false);
     }
 }

        public override object Instantiate(CompactBinaryReader reader)
        {
            int length = reader.ReadInt32();
            string typeName = reader.ReadString();
            Type t = Type.GetType(typeName);

            object graph = Array.CreateInstance(t, length);

            return graph;
        }

 public override void Skip(CompactBinaryReader reader)
 {
     int cookie = reader.ReadInt32();
     object custom = reader.Context.GetObject(cookie);
     if (custom == null)
     {
         BinaryFormatter formatter = new BinaryFormatter();
         custom = formatter.Deserialize(reader.BaseReader.BaseStream);
         reader.Context.RememberObject(custom,false);
     }
 }