private object PopulateObject(object newObject, JsonReader reader, JsonObjectContract contract, JsonProperty member, string id)
        {
            OnDeserializing(reader, contract, newObject);

            // only need to keep a track of properies presence if they are required or a value should be defaulted if missing
            Dictionary<JsonProperty, PropertyPresence> propertiesPresence = (contract.HasRequiredOrDefaultValueProperties || HasFlag(Serializer._defaultValueHandling, DefaultValueHandling.Populate))
                ? contract.Properties.ToDictionary(m => m, m => PropertyPresence.None)
                : null;

            if (id != null)
                AddReference(reader, id, newObject);

            int initialDepth = reader.Depth;

            if (contract.MemberReader != null)
            {
                contract.MemberReader(reader, newObject, GetInternalSerializer());
            }
            else
            {
                bool finished = false;
                do
                {
                    switch (reader.TokenType)
                    {
                        case JsonToken.PropertyName:
                            {
                                string memberName = reader.Value.ToString();

                                if (CheckPropertyName(reader, memberName))
                                    continue;

                                try
                                {
                                    // attempt exact case match first
                                    // then try match ignoring case
                                    JsonProperty property = contract.Properties.GetClosestMatchProperty(memberName);

                                    if (property == null)
                                    {
                                        if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose)
                                            TraceWriter.Trace(TraceLevel.Verbose, JsonPosition.FormatMessage(reader as IJsonLineInfo, reader.Path, "Could not find member '{0}' on {1}".FormatWith(CultureInfo.InvariantCulture, memberName, contract.UnderlyingType)), null);

                                        if (Serializer._missingMemberHandling == MissingMemberHandling.Error)
                                            throw JsonSerializationException.Create(reader, "Could not find member '{0}' on object of type '{1}'".FormatWith(CultureInfo.InvariantCulture, memberName, contract.UnderlyingType.Name));

                                        if (!reader.Read())
                                            break;

                                        SetExtensionData(contract, member, reader, memberName, newObject);
                                        continue;
                                    }

                                    if (property.PropertyContract == null)
                                        property.PropertyContract = GetContractSafe(property.PropertyType);

                                    JsonConverter propertyConverter = GetConverter(property.PropertyContract, property.MemberConverter, contract, member);

                                    if (!ReadForType(reader, property.PropertyContract, propertyConverter != null))
                                        throw JsonSerializationException.Create(reader, "Unexpected end when setting {0}'s value.".FormatWith(CultureInfo.InvariantCulture, memberName));

                                    SetPropertyPresence(reader, property, propertiesPresence);

                                    // set extension data if property is ignored or readonly
                                    if (!SetPropertyValue(property, propertyConverter, contract, member, reader, newObject))
                                        SetExtensionData(contract, member, reader, memberName, newObject);
                                }
                                catch (Exception ex)
                                {
                                    if (IsErrorHandled(newObject, contract, memberName, reader as IJsonLineInfo, reader.Path, ex))
                                        HandleError(reader, true, initialDepth);
                                    else
                                        throw;
                                }
                                break;
                            }
                        case JsonToken.EndObject:
                            finished = true;
                            break;
                        case JsonToken.Comment:
                            // ignore
                            break;
                        default:
                            throw JsonSerializationException.Create(reader, "Unexpected token when deserializing object: " + reader.TokenType);
                    }
                } while (!finished && reader.Read());

                if (!finished)
                    ThrowUnexpectedEndException(reader, contract, newObject, "Unexpected end when deserializing object.");
            }

            EndObject(newObject, reader, contract, initialDepth, propertiesPresence);

            OnDeserialized(reader, contract, newObject);
            return newObject;
        }