C# JsonProperty.SetIsSpecified方法代码示例

    private void SetPropertyValue(JsonProperty property, JsonConverter propertyConverter, JsonReader reader, object target)
    {
      if (property.Ignored)
      {
        reader.Skip();
        return;
      }

      object currentValue = null;
      bool useExistingValue = false;
      bool gottenCurrentValue = false;

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

      if ((objectCreationHandling == ObjectCreationHandling.Auto || objectCreationHandling == ObjectCreationHandling.Reuse)
        && (reader.TokenType == JsonToken.StartArray || reader.TokenType == JsonToken.StartObject)
          && property.Readable)
      {
        currentValue = property.ValueProvider.GetValue(target);
        gottenCurrentValue = true;

        useExistingValue = (currentValue != null
          && !property.PropertyType.IsArray
            && !ReflectionUtils.InheritsGenericDefinition(property.PropertyType, typeof (ReadOnlyCollection<>))
              && !property.PropertyType.IsValueType());
      }

      if (!property.Writable && !useExistingValue)
      {
        reader.Skip();
        return;
      }

      // 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 && reader.TokenType == JsonToken.Null)
      {
        reader.Skip();
        return;
      }

      // 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)
        && JsonReader.IsPrimitiveToken(reader.TokenType)
          && MiscellaneousUtils.ValueEquals(reader.Value, property.DefaultValue))
      {
        reader.Skip();
        return;
      }

      object existingValue = (useExistingValue) ? currentValue : null;
      object value = CreateValueProperty(reader, property, propertyConverter, target, gottenCurrentValue, existingValue);

      // 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)
          property.SetIsSpecified(target, true);
      }
    }

        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;
        }

 private void SetPropertyValue(JsonProperty property, JsonConverter propertyConverter, JsonContainerContract containerContract, JsonProperty containerProperty, JsonReader reader, object target)
 {
   bool useExistingValue;
   object currentValue;
   JsonContract propertyContract;
   bool gottenCurrentValue;
   if (this.CalculatePropertyDetails(property, ref propertyConverter, containerContract, containerProperty, reader, target, out useExistingValue, out currentValue, out propertyContract, out gottenCurrentValue))
     return;
   object obj;
   if (propertyConverter != null && propertyConverter.CanRead)
   {
     if (!gottenCurrentValue && target != null && property.Readable)
       currentValue = property.ValueProvider.GetValue(target);
     obj = propertyConverter.ReadJson(reader, property.PropertyType, currentValue, (JsonSerializer) this.GetInternalSerializer());
   }
   else
     obj = this.CreateValueInternal(reader, property.PropertyType, propertyContract, property, containerContract, containerProperty, useExistingValue ? currentValue : (object) null);
   if (useExistingValue && obj == currentValue || !this.ShouldSetPropertyValue(property, obj))
     return;
   property.ValueProvider.SetValue(target, obj);
   if (property.SetIsSpecified == null)
     return;
   property.SetIsSpecified(target, (object) true);
 }

    private void 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;

      object value;

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

        value = propertyConverter.ReadJson(reader, property.PropertyType, currentValue, GetInternalSerializer());
      }
      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)
          property.SetIsSpecified(target, true);
      }
    }

 // Token: 0x06000BC8 RID: 3016
 // RVA: 0x00044828 File Offset: 0x00042A28
 private bool SetPropertyValue(JsonProperty property, JsonConverter propertyConverter, JsonContainerContract containerContract, JsonProperty containerProperty, JsonReader reader, object target)
 {
     bool flag;
     object value;
     JsonContract contract;
     bool flag2;
     if (this.CalculatePropertyDetails(property, ref propertyConverter, containerContract, containerProperty, reader, target, out flag, out value, out contract, out flag2))
     {
         return false;
     }
     object obj;
     if (propertyConverter != null && propertyConverter.CanRead)
     {
         if (!flag2 && target != null && property.Readable)
         {
             value = property.ValueProvider.GetValue(target);
         }
         obj = this.DeserializeConvertable(propertyConverter, reader, property.PropertyType, value);
     }
     else
     {
         obj = this.CreateValueInternal(reader, property.PropertyType, contract, property, containerContract, containerProperty, flag ? value : null);
     }
     if ((!flag || obj != value) && this.ShouldSetPropertyValue(property, obj))
     {
         property.ValueProvider.SetValue(target, obj);
         if (property.SetIsSpecified != null)
         {
             if (this.TraceWriter != null && this.TraceWriter.LevelFilter >= TraceLevel.Verbose)
             {
                 this.TraceWriter.Trace(TraceLevel.Verbose, JsonPosition.FormatMessage(reader as IJsonLineInfo, reader.Path, StringUtils.FormatWith("IsSpecified for property '{0}' on {1} set to true.", CultureInfo.InvariantCulture, property.PropertyName, property.DeclaringType)), null);
             }
             property.SetIsSpecified(target, true);
         }
         return true;
     }
     return flag;
 }