title: Deserializing BSON ReadBsonType can only be called when State is Type
body: <p>I have the following Code:</p>
  
  <pre><code>using MongoDB.Bson;
  using MongoDB.Bson.IO;
  using MongoDB.Bson.Serialization.Attributes;
  using MongoDB.Bson.Serialization.Serializers;
  using MongoDB.Driver;
  using MongoDBTest;
  using ServiceStack;
  using System;
  using System.Collections.Generic;
  using System.Threading.Tasks;
  namespace protocol.server.API.Clients
  {
      public class ClientService : ServiceStack.Service
      {
          class CylinderSerializer : SerializerBase&lt;Cylinder&gt;
          {
              public override void Serialize(MongoDB.Bson.Serialization.BsonSerializationContext context, MongoDB.Bson.Serialization.BsonSerializationArgs args, Cylinder value)
              {
                  var wr = context.Writer;
  
                  wr.WriteStartDocument();
                  wr.WriteName("_id");
                  wr.WriteObjectId(ObjectId.GenerateNewId());
  
  
                wr.WriteName("description");
                  wr.WriteString(value.description.type);
  
                  context.Writer.WriteEndDocument();
              }
  
  
          public override Cylinder Deserialize(MongoDB.Bson.Serialization.BsonDeserializationContext context, MongoDB.Bson.Serialization.BsonDeserializationArgs args)
          {
              context.Reader.ReadStartDocument();
              Cylinder a = new Cylinder();
              a.Id = context.Reader.ReadObjectId();
  
  
  
  
              while (context.Reader.State != BsonReaderState.Type &amp;&amp; context.Reader.ReadBsonType() != BsonType.EndOfDocument)
              { 
                  a.description.type = context.Reader.ReadString();
                  a.description.kind = context.Reader.ReadString();
                  a.description.year = (short)context.Reader.ReadInt32();
                  a.description.producer = context.Reader.ReadString();
              }
              return a;
          }
  
  
  
          public async Task&lt;List&lt;Cylinder&gt;&gt; Get(GetObjects request)
          {
              MongoDB.Bson.Serialization.BsonSerializer.RegisterSerializer(typeof(Cylinder), new CylinderSerializer());
              IMongoCollection&lt;Cylinder&gt; collection = Connect._database.GetCollection&lt;Cylinder&gt;("Cylinders");
              var results = await collection.Find(_ =&gt; true).ToListAsync();
  
              return results;
          }
      }
  }
  </code></pre>
  
  <p>and get the error:</p>
  
  <p>ReadBsonType can only be called when State is Type, not when State is Value</p>
  
  <p>in line:</p>
  
  <pre><code> while (context.Reader.ReadBsonType() != BsonType.EndOfDocument)
  </code></pre>
  
  <p>I want to deserialize my objects, they look like this:</p>
  
  <pre><code>{ 
      "_id" : ObjectId("5826010eb831ee1c70df5f16"), 
      "description" : {
          "type" : "Cylinder", 
          "kind" : "rgdgg", 
          "year" : NumberInt(1997), 
          "producer" : "hnnghng", 
          "brands" : [
              "trhr"
          ], 
          "model" : [
              "Baws"
          ], 
          "internalproducerdesignation" : "tw6", 
          "origin" : "Greece"
      }, 
      "elements" : {
          "nonspringelements" : NumberInt(0), 
          "springelements" : NumberInt(11), 
          "discelements" : NumberInt(0), 
          "magneticelements" : NumberInt(0), 
          "activeelements" : NumberInt(11), 
          "passiveelements" : NumberInt(0), 
          "totalelements" : NumberInt(11)
      }, 
      "profiles" : [
          "d1", 
          "d11"
      ], 
      "certifications" : [
          "", 
          ""
      ], 
      "colors" : [
          "brown", 
          "chrome"
      ], 
      "specialfittings" : [
          "gf", 
          "hrthr", 
          "hgnn", 
          "ngnn", 
          "hngngn", 
          "nghnnn"
      ], 
      "cutdepths" : NumberInt(7), 
      "rareness" : "rare", 
      "value" : {
          "new" : "0", 
          "used" : "$50"
      }, 
      "Blaw" : {
          "tgtgt" : 10.0, 
          "hzhz" : true
      }, 
      "availableat" : "gtgtgtgt", 
      "specialabout" : "jujujuju", 
      "development" : {
          "predecessor" : "", 
          "follower" : "rfrfr"
      }, 
      "media" : [
  
      ]
  }
  </code></pre>
  
  <p>My Clinder.cs :</p>
  
  <pre><code>using MongoDB.Bson;
  using MongoDB.Bson.IO;
  using MongoDB.Bson.Serialization.Attributes;
  using System;
  using System.Collections.Generic;
  using System.Globalization;
  using MongoDB.Bson.Serialization;
  using MongoDB.Bson.Serialization.Serializers;
  
  namespace protocol.server.API.Clients
  {
  
      public class Cylinder
      {
          [BsonSerializer(typeof(ProductAttributeSerializer))]
          public class ProductAttributeSerializer : IBsonSerializer, IBsonArraySerializer
          {
              public Type ValueType { get { return typeof(List&lt;string&gt;); } }
  
              public object Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
              {
                  var type = context.Reader.GetCurrentBsonType();
                  List&lt;String&gt; items = new List&lt;String&gt;();
  
                  switch (type)
                  {
                      case BsonType.Document:
  
  
                      case BsonType.Array:
  
                          context.Reader.ReadStartArray();
  
                          while (context.Reader.ReadBsonType() != BsonType.EndOfDocument)
                          {
                              items.Add(context.Reader.ReadString());
                          }
                          context.Reader.ReadEndArray();
                          return new mode(items);
  
                      default:
                          throw new NotImplementedException($"No implementation to deserialize {type}");
                  }
              }
  
              public void Serialize(BsonSerializationContext context, BsonSerializationArgs args, object value)
              {
  
                  var d = value;
                  var attributes = value as List&lt;string&gt;;
  
                  if (attributes != null)
                  {
                      context.Writer.WriteStartArray();
  
                      foreach (string attr in attributes)
                      {
                          context.Writer.WriteString(attr);
                      }
  
                      context.Writer.WriteEndArray();
                  }
              }
  
              public bool TryGetItemSerializationInfo(out BsonSerializationInfo serializationInfo)
              {
                  string elementName = null;
                  var serializer = BsonSerializer.LookupSerializer(typeof(string));
                  var nominalType = typeof(string);
                  serializationInfo = new BsonSerializationInfo(elementName, serializer, nominalType);
                  return true;
              }
          }
  
  
          [BsonId]
          public ObjectId Id { get; set; }
  
          [BsonSerializer(typeof(ProductAttributeSerializer))]
          public class mode
          {
              public mode(List&lt;String&gt; pItems)
              {
                  this.items = new List&lt;String&gt;();
                  this.items.Clear();
                  this.items.AddRange(pItems);
              }
              public List&lt;String&gt; items { get; set; }
          }
  
  
          public class des
          {
              public string type { get; set; }
              public string kind { get; set; }
              public short year { get; set; }
              public string producer { get; set; }
  
              public List&lt;string&gt; brands { get; set; }
  
              public string internalproducerdesignation { get; set; }
              public string origin { get; set; }
  
              public mode model { get; set; }
          }
          public class elem
          {
              public short nonspringelements { get; set; }
              public short springelements { get; set; }
              public short discelements { get; set; }
              public short magneticelements { get; set; }
              public short activeelements { get; set; }
              public short passiveelements { get; set; }
              public short totalelements { get; set; }
          }
          public des description = new des();
          public elem elements = new elem();
  
          public IEnumerable&lt;string&gt; profiles { get; set; }
          public IEnumerable&lt;string&gt; certifications { get; set; }
          public IEnumerable&lt;string&gt; colors { get; set; }
          public IEnumerable&lt;string&gt; specialfittings { get; set; }
          public short cutdepths { get; set; }
          public string rareness { get; set; }
  
          public class val
          {
              public String @new { get; set; }
              public String used { get; set; }
          }
          public val value = new val();
  
          public class Pi
          {
              public Double difficulty { get; set; }
              public bool alreadypicked { get; set; }
          }
          public Pi Picking = new Pi();
          public string availableat { get; set; }
          public string specialabout { get; set; }
  
          public class devel
          {
              public string predecessor { get; set; }
              public string follower { get; set; }
          }
  
          public devel development = new devel();
  
          public Object[] media;
  
  
      }
  }
  </code></pre>
  
  <p>How to prevent this error ? I just want to deserialize my objects...</p>