C# Serialization.JsonContainerContract类代码示例

    private void SerializePrimitive(JsonWriter writer, object value, JsonPrimitiveContract contract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerProperty)
    {
      if (contract.UnderlyingType == typeof (byte[]))
      {
        bool includeTypeDetails = ShouldWriteType(TypeNameHandling.Objects, contract, member, containerContract, containerProperty);
        if (includeTypeDetails)
        {
          writer.WriteStartObject();
          WriteTypeProperty(writer, contract.CreatedType);
          writer.WritePropertyName(JsonTypeReflector.ValuePropertyName);

          if (contract.IsNullable)
            writer.WriteValue(value, true);
          else
            writer.WriteValue(value);

          writer.WriteEndObject();
          return;
        }
      }

      if (contract.IsNullable)
        writer.WriteValue(value, true);
      else
        writer.WriteValue(value);
    }

 /// <summary>
 /// Initializes a new instance of the <see cref="JSchemaTypeGenerationContext"/> class.
 /// </summary>
 /// <param name="objectType">The object type.</param>
 /// <param name="required">The required state.</param>
 /// <param name="memberProperty">The member property.</param>
 /// <param name="parentContract">The parent contract.</param>
 /// <param name="generator">The current <see cref="JSchemaGenerator"/>.</param>
 public JSchemaTypeGenerationContext(Type objectType, Required required, JsonProperty memberProperty, JsonContainerContract parentContract, JSchemaGenerator generator)
 {
     _objectType = objectType;
     _required = required;
     _memberProperty = memberProperty;
     _parentContract = parentContract;
     _generator = generator;
 }

 private void SerializeValue(JsonWriter writer, object value, JsonContract valueContract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerProperty)
 {
   if (value == null)
   {
     writer.WriteNull();
   }
   else
   {
     JsonConverter converter;
     if (((converter = member != null ? member.Converter : (JsonConverter) null) != null || (converter = containerProperty != null ? containerProperty.ItemConverter : (JsonConverter) null) != null || ((converter = containerContract != null ? containerContract.ItemConverter : (JsonConverter) null) != null || (converter = valueContract.Converter) != null || ((converter = this.Serializer.GetMatchingConverter(valueContract.UnderlyingType)) != null || (converter = valueContract.InternalConverter) != null))) && converter.CanWrite)
     {
       this.SerializeConvertable(writer, converter, value, valueContract, containerContract, containerProperty);
     }
     else
     {
       switch (valueContract.ContractType)
       {
         case JsonContractType.Object:
           this.SerializeObject(writer, value, (JsonObjectContract) valueContract, member, containerContract, containerProperty);
           break;
         case JsonContractType.Array:
           JsonArrayContract contract1 = (JsonArrayContract) valueContract;
           if (!contract1.IsMultidimensionalArray)
           {
             this.SerializeList(writer, contract1.CreateWrapper(value), contract1, member, containerContract, containerProperty);
             break;
           }
           else
           {
             this.SerializeMultidimensionalArray(writer, (Array) value, contract1, member, containerContract, containerProperty);
             break;
           }
         case JsonContractType.Primitive:
           this.SerializePrimitive(writer, value, (JsonPrimitiveContract) valueContract, member, containerContract, containerProperty);
           break;
         case JsonContractType.String:
           this.SerializeString(writer, value, (JsonStringContract) valueContract);
           break;
         case JsonContractType.Dictionary:
           JsonDictionaryContract contract2 = (JsonDictionaryContract) valueContract;
           this.SerializeDictionary(writer, contract2.CreateWrapper(value), contract2, member, containerContract, containerProperty);
           break;
         case JsonContractType.Serializable:
           this.SerializeISerializable(writer, (ISerializable) value, (JsonISerializableContract) valueContract, member, containerContract, containerProperty);
           break;
         case JsonContractType.Linq:
           ((JToken) value).WriteTo(writer, this.Serializer.Converters != null ? Enumerable.ToArray<JsonConverter>((IEnumerable<JsonConverter>) this.Serializer.Converters) : (JsonConverter[]) null);
           break;
       }
     }
   }
 }

 private void SerializePrimitive(JsonWriter writer, object value, JsonPrimitiveContract contract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerProperty)
 {
   if (contract.UnderlyingType == typeof (byte[]) && this.ShouldWriteType(TypeNameHandling.Objects, (JsonContract) contract, member, containerContract, containerProperty))
   {
     writer.WriteStartObject();
     this.WriteTypeProperty(writer, contract.CreatedType);
     writer.WritePropertyName("$value");
     writer.WriteValue(value);
     writer.WriteEndObject();
   }
   else
     writer.WriteValue(value);
 }

    private void SerializePrimitive(JsonWriter writer, object value, JsonPrimitiveContract contract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerProperty)
    {
      if (contract.TypeCode == PrimitiveTypeCode.Bytes)
      {
        // if type name handling is enabled then wrap the base64 byte string in an object with the type name
        bool includeTypeDetails = ShouldWriteType(TypeNameHandling.Objects, contract, member, containerContract, containerProperty);
        if (includeTypeDetails)
        {
          writer.WriteStartObject();
          WriteTypeProperty(writer, contract.CreatedType);
          writer.WritePropertyName(JsonTypeReflector.ValuePropertyName, false);

          JsonWriter.WriteValue(writer, contract.TypeCode, value);

          writer.WriteEndObject();
          return;
        }
      }

      JsonWriter.WriteValue(writer, contract.TypeCode, value);
    }

    private bool CheckForCircularReference(JsonWriter writer, object value, JsonProperty property, JsonContract contract, JsonContainerContract containerContract, JsonProperty containerProperty)
    {
      if (value == null || contract.ContractType == JsonContractType.Primitive || contract.ContractType == JsonContractType.String)
        return true;

      ReferenceLoopHandling? referenceLoopHandling = null;

      if (property != null)
        referenceLoopHandling = property.ReferenceLoopHandling;

      if (referenceLoopHandling == null && containerProperty != null)
        referenceLoopHandling = containerProperty.ItemReferenceLoopHandling;

      if (referenceLoopHandling == null && containerContract != null)
        referenceLoopHandling = containerContract.ItemReferenceLoopHandling;

      if (_serializeStack.IndexOf(value) != -1)
      {
        switch (referenceLoopHandling.GetValueOrDefault(Serializer.ReferenceLoopHandling))
        {
          case ReferenceLoopHandling.Error:
            string message = "Self referencing loop detected";
            if (property != null)
              message += " for property '{0}'".FormatWith(CultureInfo.InvariantCulture, property.PropertyName);
            message += " with type '{0}'.".FormatWith(CultureInfo.InvariantCulture, value.GetType());

            throw JsonSerializationException.Create(null, writer.ContainerPath, message, null);
          case ReferenceLoopHandling.Ignore:
            return false;
          case ReferenceLoopHandling.Serialize:
            return true;
          default:
            throw new InvalidOperationException("Unexpected ReferenceLoopHandling value: '{0}'".FormatWith(CultureInfo.InvariantCulture, Serializer.ReferenceLoopHandling));
        }
      }

      return true;
    }

    private bool ShouldWriteReference(object value, JsonProperty property, JsonContract valueContract, JsonContainerContract collectionContract, JsonProperty containerProperty)
    {
      if (value == null)
        return false;
      if (valueContract.ContractType == JsonContractType.Primitive || valueContract.ContractType == JsonContractType.String)
        return false;

      bool? isReference = ResolveIsReference(valueContract, property, collectionContract, containerProperty);

      if (isReference == null)
      {
        if (valueContract.ContractType == JsonContractType.Array)
          isReference = HasFlag(Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Arrays);
        else
          isReference = HasFlag(Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Objects);
      }

      if (!isReference.Value)
        return false;

      return Serializer.ReferenceResolver.IsReferenced(this, value);
    }

    private bool WriteStartArray(JsonWriter writer, object values, JsonArrayContract contract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerProperty)
    {
      bool isReference = ResolveIsReference(contract, member, containerContract, containerProperty) ?? HasFlag(Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Arrays);
      bool includeTypeDetails = ShouldWriteType(TypeNameHandling.Arrays, contract, member, containerContract, containerProperty);
      bool writeMetadataObject = isReference || includeTypeDetails;

      if (writeMetadataObject)
      {
        writer.WriteStartObject();

        if (isReference)
        {
          writer.WritePropertyName(JsonTypeReflector.IdPropertyName);
          writer.WriteValue(Serializer.ReferenceResolver.GetReference(this, values));
        }
        if (includeTypeDetails)
        {
          WriteTypeProperty(writer, values.GetType());
        }
        writer.WritePropertyName(JsonTypeReflector.ArrayValuesPropertyName);
      }

      if (contract.ItemContract == null)
        contract.ItemContract = Serializer.ContractResolver.ResolveContract(contract.CollectionItemType ?? typeof (object));

      return writeMetadataObject;
    }

    private void SerializeList(JsonWriter writer, IWrappedCollection values, JsonArrayContract contract, JsonProperty member, JsonContainerContract collectionContract, JsonProperty containerProperty)
    {
      contract.InvokeOnSerializing(values.UnderlyingCollection, Serializer.Context);

      _serializeStack.Add(values.UnderlyingCollection);

      bool hasWrittenMetadataObject = WriteStartArray(writer, values.UnderlyingCollection, contract, member, collectionContract, containerProperty);

      writer.WriteStartArray();

      int initialDepth = writer.Top;

      int index = 0;
      // note that an error in the IEnumerable won't be caught
      foreach (object value in values)
      {
        try
        {
          JsonContract valueContract = contract.FinalItemContract ?? GetContractSafe(value);

          if (ShouldWriteReference(value, null, valueContract, contract, member))
          {
            WriteReference(writer, value);
          }
          else
          {
            if (CheckForCircularReference(writer, value, null, valueContract, contract, member))
            {
              SerializeValue(writer, value, valueContract, null, contract, member);
            }
          }
        }
        catch (Exception ex)
        {
          if (IsErrorHandled(values.UnderlyingCollection, contract, index, writer.ContainerPath, ex))
            HandleError(writer, initialDepth);
          else
            throw;
        }
        finally
        {
          index++;
        }
      }

      writer.WriteEndArray();

      if (hasWrittenMetadataObject)
        writer.WriteEndObject();

      _serializeStack.RemoveAt(_serializeStack.Count - 1);

      contract.InvokeOnSerialized(values.UnderlyingCollection, Serializer.Context);
    }

    private void WriteObjectStart(JsonWriter writer, object value, JsonContract contract, JsonProperty member, JsonContainerContract collectionContract, JsonProperty containerProperty)
    {
      writer.WriteStartObject();

      bool isReference = ResolveIsReference(contract, member, collectionContract, containerProperty) ?? HasFlag(Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Objects);
      if (isReference)
      {
        writer.WritePropertyName(JsonTypeReflector.IdPropertyName);
        writer.WriteValue(Serializer.ReferenceResolver.GetReference(this, value));
      }
      if (ShouldWriteType(TypeNameHandling.Objects, contract, member, collectionContract, containerProperty))
      {
        WriteTypeProperty(writer, contract.UnderlyingType);
      }
    }

 private JsonConverter GetConverter(JsonContract contract, JsonConverter memberConverter, JsonContainerContract containerContract, JsonProperty containerProperty)
 {
     JsonConverter converter = null;
       if (memberConverter != null)
       {
     // member attribute converter
     converter = memberConverter;
       }
       else if (containerProperty != null && containerProperty.ItemConverter != null)
       {
     converter = containerProperty.ItemConverter;
       }
       else if (containerContract != null && containerContract.ItemConverter != null)
       {
     converter = containerContract.ItemConverter;
       }
       else if (contract != null)
       {
     JsonConverter matchingConverter;
     if (contract.Converter != null)
       // class attribute converter
       converter = contract.Converter;
     else if ((matchingConverter = Serializer.GetMatchingConverter(contract.UnderlyingType)) != null)
       // passed in converters
       converter = matchingConverter;
     else if (contract.InternalConverter != null)
       // internally specified converter
       converter = contract.InternalConverter;
       }
       return converter;
 }

        private object CreateValueInternal(JsonReader reader, Type objectType, JsonContract contract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerMember, object existingValue)
        {
            if (contract != null && contract.ContractType == JsonContractType.Linq)
            return CreateJToken(reader, contract);

              do
              {
            switch (reader.TokenType)
            {
            // populate a typed object or generic dictionary/array
            // depending upon whether an objectType was supplied
              case JsonToken.StartObject:
            return CreateObject(reader, objectType, contract, member, containerContract, containerMember, existingValue);
              case JsonToken.StartArray:
            return CreateList(reader, objectType, contract, member, existingValue, null);
              case JsonToken.Integer:
              case JsonToken.Float:
              case JsonToken.Boolean:
              case JsonToken.Date:
              case JsonToken.Bytes:
            return EnsureType(reader, reader.Value, CultureInfo.InvariantCulture, contract, objectType);
              case JsonToken.String:
            string s = (string)reader.Value;

            // convert empty string to null automatically for nullable types
            if (string.IsNullOrEmpty(s) && objectType != typeof(string) && objectType != typeof(object) && contract != null && contract.IsNullable)
              return null;

            // string that needs to be returned as a byte array should be base 64 decoded
            if (objectType == typeof (byte[]))
              return Convert.FromBase64String(s);

            return EnsureType(reader, s, CultureInfo.InvariantCulture, contract, objectType);
              case JsonToken.StartConstructor:
            string constructorName = reader.Value.ToString();

            return EnsureType(reader, constructorName, CultureInfo.InvariantCulture, contract, objectType);
              case JsonToken.Null:
              case JsonToken.Undefined:
            #if !(NETFX_CORE || PORTABLE40 || PORTABLE)
            if (objectType == typeof (DBNull))
              return DBNull.Value;
            #endif

            return EnsureType(reader, reader.Value, CultureInfo.InvariantCulture, contract, objectType);
              case JsonToken.Raw:
            return new JRaw((string) reader.Value);
              case JsonToken.Comment:
            // ignore
            break;
              default:
            throw JsonSerializationException.Create(reader, "Unexpected token while deserializing object: " + reader.TokenType);
            }
              } while (reader.Read());

              throw JsonSerializationException.Create(reader, "Unexpected end when deserializing object.");
        }

        private object CreateObject(JsonReader reader, Type objectType, JsonContract contract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerMember, object existingValue)
        {
            CheckedRead(reader);

              string id;
              object newValue;
              if (ReadSpecialProperties(reader, ref objectType, ref contract, member, containerContract, containerMember, existingValue, out newValue, out id))
            return newValue;

              if (HasNoDefinedType(contract))
            return CreateJObject(reader);

              switch (contract.ContractType)
              {
            case JsonContractType.Object:
              {
            bool createdFromNonDefaultConstructor = false;
            JsonObjectContract objectContract = (JsonObjectContract) contract;
            object targetObject;
            if (existingValue != null)
              targetObject = existingValue;
            else
              targetObject = CreateNewObject(reader, objectContract, member, containerMember, id, out createdFromNonDefaultConstructor);

            // don't populate if read from non-default constructor because the object has already been read
            if (createdFromNonDefaultConstructor)
              return targetObject;

            return PopulateObject(targetObject, reader, objectContract, member, id);
              }
            case JsonContractType.Primitive:
              {
            JsonPrimitiveContract primitiveContract = (JsonPrimitiveContract) contract;
            // if the content is inside $value then read past it
            if (reader.TokenType == JsonToken.PropertyName && string.Equals(reader.Value.ToString(), JsonTypeReflector.ValuePropertyName, StringComparison.Ordinal))
            {
              CheckedRead(reader);

              // the token should not be an object because the $type value could have been included in the object
              // without needing the $value property
              if (reader.TokenType == JsonToken.StartObject)
                throw JsonSerializationException.Create(reader, "Unexpected token when deserializing primitive value: " + reader.TokenType);

              object value = CreateValueInternal(reader, objectType, primitiveContract, member, null, null, existingValue);

              CheckedRead(reader);
              return value;
            }
            break;
              }
            case JsonContractType.Dictionary:
              {
            JsonDictionaryContract dictionaryContract = (JsonDictionaryContract) contract;
            object targetDictionary;

            if (existingValue == null)
            {
              bool createdFromNonDefaultConstructor;
              IDictionary dictionary = CreateNewDictionary(reader, dictionaryContract, out createdFromNonDefaultConstructor);

              if (createdFromNonDefaultConstructor)
              {
                if (id != null)
                  throw JsonSerializationException.Create(reader, "Cannot preserve reference to readonly dictionary, or dictionary created from a non-default constructor: {0}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));

                if (contract.OnSerializingCallbacks.Count > 0)
                  throw JsonSerializationException.Create(reader, "Cannot call OnSerializing on readonly dictionary, or dictionary created from a non-default constructor: {0}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));

                if (contract.OnErrorCallbacks.Count > 0)
                  throw JsonSerializationException.Create(reader, "Cannot call OnError on readonly list, or dictionary created from a non-default constructor: {0}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));

                if (dictionaryContract.ParametrizedConstructor == null)
                  throw JsonSerializationException.Create(reader, "Cannot deserialize readonly or fixed size dictionary: {0}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));
              }

              PopulateDictionary(dictionary, reader, dictionaryContract, member, id);

              if (createdFromNonDefaultConstructor)
              {
                ConstructorInfo constructor = dictionaryContract.ParametrizedConstructor as ConstructorInfo;
                if (constructor != null)
                  return constructor.Invoke(new object[] { dictionary });

                return dictionaryContract.ParametrizedConstructor.Invoke(null, new object[] { dictionary });
              }
              else if (dictionary is IWrappedDictionary)
              {
                return ((IWrappedDictionary)dictionary).UnderlyingDictionary;
              }

              targetDictionary = dictionary;
            }
            else
            {
              targetDictionary = PopulateDictionary(dictionaryContract.ShouldCreateWrapper ? dictionaryContract.CreateWrapper(existingValue) : (IDictionary) existingValue, reader, dictionaryContract, member, id);
            }

            return targetDictionary;
              }
            #if !(NET35 || NET20 || PORTABLE40)
//.........这里部分代码省略.........

        private bool CalculatePropertyDetails(JsonProperty property, ref JsonConverter propertyConverter, JsonContainerContract containerContract, JsonProperty containerProperty, JsonReader reader, object target, out bool useExistingValue, out object currentValue, out JsonContract propertyContract, out bool gottenCurrentValue)
        {
            currentValue = null;
              useExistingValue = false;
              propertyContract = null;
              gottenCurrentValue = false;

              if (property.Ignored)
            return true;

              JsonToken tokenType = reader.TokenType;

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

              ObjectCreationHandling objectCreationHandling =
            property.ObjectCreationHandling.GetValueOrDefault(Serializer._objectCreationHandling);

              if ((objectCreationHandling != ObjectCreationHandling.Replace)
              && (tokenType == JsonToken.StartArray || tokenType == JsonToken.StartObject)
              && property.Readable)
              {
            currentValue = property.ValueProvider.GetValue(target);
            gottenCurrentValue = true;

            if (currentValue != null)
            {
              propertyContract = GetContractSafe(currentValue.GetType());

              useExistingValue = (!propertyContract.IsReadOnlyOrFixedSize && !propertyContract.UnderlyingType.IsValueType());
            }
              }

              if (!property.Writable && !useExistingValue)
            return true;

              // test tokentype here because null might not be convertable to some types, e.g. ignoring null when applied to DateTime
              if (property.NullValueHandling.GetValueOrDefault(Serializer._nullValueHandling) == NullValueHandling.Ignore && tokenType == JsonToken.Null)
            return true;

              // test tokentype here because default value might not be convertable to actual type, e.g. default of "" for DateTime
              if (HasFlag(property.DefaultValueHandling.GetValueOrDefault(Serializer._defaultValueHandling), DefaultValueHandling.Ignore)
              && !HasFlag(property.DefaultValueHandling.GetValueOrDefault(Serializer._defaultValueHandling), DefaultValueHandling.Populate)
              && JsonReader.IsPrimitiveToken(tokenType)
              && MiscellaneousUtils.ValueEquals(reader.Value, property.GetResolvedDefaultValue()))
            return true;

              if (currentValue == null)
              {
            propertyContract = property.PropertyContract;
              }
              else
              {
            propertyContract = GetContractSafe(currentValue.GetType());

            if (propertyContract != property.PropertyContract)
              propertyConverter = GetConverter(propertyContract, property.MemberConverter, containerContract, containerProperty);
              }

              return false;
        }

        private bool SetPropertyValue(JsonProperty property, JsonConverter propertyConverter, JsonContainerContract containerContract, JsonProperty containerProperty, JsonReader reader, object target)
        {
            object currentValue;
              bool useExistingValue;
              JsonContract propertyContract;
              bool gottenCurrentValue;

              if (CalculatePropertyDetails(property, ref propertyConverter, containerContract, containerProperty, reader, target, out useExistingValue, out currentValue, out propertyContract, out gottenCurrentValue))
            return false;

              object value;

              if (propertyConverter != null && propertyConverter.CanRead)
              {
            if (!gottenCurrentValue && target != null && property.Readable)
              currentValue = property.ValueProvider.GetValue(target);

            value = DeserializeConvertable(propertyConverter, reader, property.PropertyType, currentValue);
              }
              else
              {
            value = CreateValueInternal(reader, property.PropertyType, propertyContract, property, containerContract, containerProperty, (useExistingValue) ? currentValue : null);
              }

              // always set the value if useExistingValue is false,
              // otherwise also set it if CreateValue returns a new value compared to the currentValue
              // this could happen because of a JsonConverter against the type
              if ((!useExistingValue || value != currentValue)
            && ShouldSetPropertyValue(property, value))
              {
            property.ValueProvider.SetValue(target, value);

            if (property.SetIsSpecified != null)
            {
              if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose)
            TraceWriter.Trace(TraceLevel.Verbose, JsonPosition.FormatMessage(reader as IJsonLineInfo, reader.Path, "IsSpecified for property '{0}' on {1} set to true.".FormatWith(CultureInfo.InvariantCulture, property.PropertyName, property.DeclaringType)), null);

              property.SetIsSpecified(target, true);
            }

            return true;
              }

              // the value wasn't set be JSON was populated onto the existing value
              return useExistingValue;
        }