Repository: JamesNK/Newtonsoft.Json
Branch: master
Commit: 4f73e7437244
Files: 1163
Total size: 14.7 MB
Directory structure:
gitextract_wyahh53l/
├── .gitattributes
├── .github/
│ └── workflows/
│ └── codeql.yml
├── .gitignore
├── Build/
│ ├── Sign-Package.ps1
│ ├── appsettings.json
│ ├── build.ps1
│ ├── localbuild.ps1
│ ├── psake.psm1
│ ├── runbuild.cmd
│ ├── runbuild.ps1
│ └── version.json
├── CONTRIBUTING.md
├── Doc/
│ ├── ConditionalProperties.aml
│ ├── ContractResolver.aml
│ ├── ConvertingJSONandXML.aml
│ ├── CreatingLINQtoJSON.aml
│ ├── CustomCreationConverter.aml
│ ├── DatesInJSON.aml
│ ├── Introduction.aml
│ ├── JsonNetVsDotNetSerializers.aml
│ ├── JsonSchema.aml
│ ├── LINQtoJSON.aml
│ ├── ParsingLINQtoJSON.aml
│ ├── Performance.aml
│ ├── PreserveObjectReferences.aml
│ ├── QueryingLINQtoJSON.aml
│ ├── ReadingWritingJSON.aml
│ ├── ReducingSerializedJSONSize.aml
│ ├── Samples/
│ │ ├── Bson/
│ │ │ ├── DeserializeFromBson.aml
│ │ │ ├── DeserializeFromBsonCollection.aml
│ │ │ └── SerializeToBson.aml
│ │ ├── Json/
│ │ │ ├── CustomJsonReader.aml
│ │ │ ├── CustomJsonWriter.aml
│ │ │ ├── ReadJsonWithJsonTextReader.aml
│ │ │ ├── ReadMultipleContentWithJsonReader.aml
│ │ │ └── WriteJsonWithJsonTextWriter.aml
│ │ ├── JsonPath/
│ │ │ ├── ErrorWhenNoMatchQuery.aml
│ │ │ ├── QueryJsonSelectToken.aml
│ │ │ ├── QueryJsonSelectTokenEscaped.aml
│ │ │ ├── QueryJsonSelectTokenJsonPath.aml
│ │ │ ├── QueryJsonSelectTokenWithLinq.aml
│ │ │ ├── RegexQuery.aml
│ │ │ └── StrictEqualsQuery.aml
│ │ ├── Linq/
│ │ │ ├── Clone.aml
│ │ │ ├── CreateJsonAnonymousObject.aml
│ │ │ ├── CreateJsonCollectionInitializer.aml
│ │ │ ├── CreateJsonDeclaratively.aml
│ │ │ ├── CreateJsonDynamic.aml
│ │ │ ├── CreateJsonJTokenWriter.aml
│ │ │ ├── CreateJsonManually.aml
│ │ │ ├── CreateReader.aml
│ │ │ ├── CreateWriter.aml
│ │ │ ├── DeepEquals.aml
│ │ │ ├── DeserializeWithLinq.aml
│ │ │ ├── FromObject.aml
│ │ │ ├── JObjectProperties.aml
│ │ │ ├── JTokenAnnotation.aml
│ │ │ ├── JValueCast.aml
│ │ │ ├── JValueValue.aml
│ │ │ ├── MergeJson.aml
│ │ │ ├── ModifyJson.aml
│ │ │ ├── ParseJsonAny.aml
│ │ │ ├── ParseJsonArray.aml
│ │ │ ├── ParseJsonObject.aml
│ │ │ ├── QueryJson.aml
│ │ │ ├── QueryJsonDynamic.aml
│ │ │ ├── QueryJsonLinq.aml
│ │ │ ├── ReadJTokenFromBson.aml
│ │ │ ├── ReadJson.aml
│ │ │ ├── SerializeWithLinq.aml
│ │ │ ├── ToObjectComplex.aml
│ │ │ ├── ToObjectGeneric.aml
│ │ │ ├── ToObjectType.aml
│ │ │ ├── ToString.aml
│ │ │ ├── ToStringJsonConverter.aml
│ │ │ ├── WriteJTokenToBson.aml
│ │ │ └── WriteToJsonFile.aml
│ │ ├── Samples.aml
│ │ ├── Schema/
│ │ │ ├── CreateJsonSchemaManually.aml
│ │ │ ├── JTokenIsValid.aml
│ │ │ ├── JTokenIsValidWithMessages.aml
│ │ │ ├── JTokenValidateWithEvent.aml
│ │ │ ├── JsonSchemaParse.aml
│ │ │ ├── JsonValidatingReaderAndSerializer.aml
│ │ │ ├── LoadJsonSchemaFromFile.aml
│ │ │ ├── RefJsonSchemaResolver.aml
│ │ │ └── SaveJsonSchemaToFile.aml
│ │ ├── Serializer/
│ │ │ ├── CustomContractResolver.aml
│ │ │ ├── CustomJsonConverter.aml
│ │ │ ├── CustomJsonConverterGeneric.aml
│ │ │ ├── CustomTraceWriter.aml
│ │ │ ├── DataContractAndDataMember.aml
│ │ │ ├── DefaultSettings.aml
│ │ │ ├── DefaultValueAttributeIgnore.aml
│ │ │ ├── DefaultValueHandlingIgnore.aml
│ │ │ ├── DeserializeAnonymousType.aml
│ │ │ ├── DeserializeCollection.aml
│ │ │ ├── DeserializeConstructorHandling.aml
│ │ │ ├── DeserializeCustomCreationConverter.aml
│ │ │ ├── DeserializeDataSet.aml
│ │ │ ├── DeserializeDateFormatString.aml
│ │ │ ├── DeserializeDictionary.aml
│ │ │ ├── DeserializeExtensionData.aml
│ │ │ ├── DeserializeImmutableCollections.aml
│ │ │ ├── DeserializeMetadataPropertyHandling.aml
│ │ │ ├── DeserializeMissingMemberHandling.aml
│ │ │ ├── DeserializeObject.aml
│ │ │ ├── DeserializeObjectCreationHandling.aml
│ │ │ ├── DeserializeWithDependencyInjection.aml
│ │ │ ├── DeserializeWithJsonSerializerFromFile.aml
│ │ │ ├── ErrorHandlingAttribute.aml
│ │ │ ├── ErrorHandlingEvent.aml
│ │ │ ├── JsonConstructorAttribute.aml
│ │ │ ├── JsonConverterAttributeClass.aml
│ │ │ ├── JsonConverterAttributeProperty.aml
│ │ │ ├── JsonObjectAttributeOptIn.aml
│ │ │ ├── JsonObjectAttributeOverrideIEnumerable.aml
│ │ │ ├── JsonPropertyItemLevelSetting.aml
│ │ │ ├── JsonPropertyName.aml
│ │ │ ├── JsonPropertyOrder.aml
│ │ │ ├── JsonPropertyPropertyLevelSetting.aml
│ │ │ ├── JsonPropertyRequired.aml
│ │ │ ├── MaxDepth.aml
│ │ │ ├── NamingStrategyAttributes.aml
│ │ │ ├── NamingStrategyCamelCase.aml
│ │ │ ├── NamingStrategySkipDictionaryKeys.aml
│ │ │ ├── NamingStrategySkipSpecifiedNames.aml
│ │ │ ├── NamingStrategySnakeCase.aml
│ │ │ ├── NullValueHandlingIgnore.aml
│ │ │ ├── PopulateObject.aml
│ │ │ ├── PreserveReferencesHandlingObject.aml
│ │ │ ├── PropertyJsonIgnore.aml
│ │ │ ├── ReferenceLoopHandlingIgnore.aml
│ │ │ ├── SerializationCallbackAttributes.aml
│ │ │ ├── SerializeCollection.aml
│ │ │ ├── SerializeConditionalProperty.aml
│ │ │ ├── SerializeContractResolver.aml
│ │ │ ├── SerializeDataSet.aml
│ │ │ ├── SerializeDateFormatHandling.aml
│ │ │ ├── SerializeDateFormatString.aml
│ │ │ ├── SerializeDateTimeZoneHandling.aml
│ │ │ ├── SerializeDictionary.aml
│ │ │ ├── SerializeExtensionData.aml
│ │ │ ├── SerializeImmutableCollections.aml
│ │ │ ├── SerializeObject.aml
│ │ │ ├── SerializeRawJson.aml
│ │ │ ├── SerializeSerializationBinder.aml
│ │ │ ├── SerializeTypeNameHandling.aml
│ │ │ ├── SerializeUnindentedJson.aml
│ │ │ ├── SerializeWithJsonConverters.aml
│ │ │ ├── SerializeWithJsonSerializerToFile.aml
│ │ │ └── TraceWriter.aml
│ │ └── Xml/
│ │ ├── ConvertJsonToXml.aml
│ │ ├── ConvertXmlToJson.aml
│ │ └── ConvertXmlToJsonForceArray.aml
│ ├── SelectToken.aml
│ ├── SerializationAttributes.aml
│ ├── SerializationCallbacks.aml
│ ├── SerializationErrorHandling.aml
│ ├── SerializationGuide.aml
│ ├── SerializationSettings.aml
│ ├── SerializationTracing.aml
│ ├── SerializingCollections.aml
│ ├── SerializingJSON.aml
│ ├── SerializingJSONFragments.aml
│ ├── doc.content
│ ├── doc.shfbproj
│ ├── license.txt
│ └── readme.txt
├── ISSUE_TEMPLATE.md
├── LICENSE.md
├── README.md
├── Src/
│ ├── Directory.Build.props
│ ├── Newtonsoft.Json/
│ │ ├── Bson/
│ │ │ ├── BsonBinaryType.cs
│ │ │ ├── BsonBinaryWriter.cs
│ │ │ ├── BsonObjectId.cs
│ │ │ ├── BsonReader.cs
│ │ │ ├── BsonToken.cs
│ │ │ ├── BsonType.cs
│ │ │ └── BsonWriter.cs
│ │ ├── CompatibilitySuppressions.xml
│ │ ├── ConstructorHandling.cs
│ │ ├── Converters/
│ │ │ ├── BinaryConverter.cs
│ │ │ ├── BsonObjectIdConverter.cs
│ │ │ ├── CustomCreationConverter.cs
│ │ │ ├── DataSetConverter.cs
│ │ │ ├── DataTableConverter.cs
│ │ │ ├── DateTimeConverterBase.cs
│ │ │ ├── DiscriminatedUnionConverter.cs
│ │ │ ├── EntityKeyMemberConverter.cs
│ │ │ ├── ExpandoObjectConverter.cs
│ │ │ ├── IsoDateTimeConverter.cs
│ │ │ ├── JavaScriptDateTimeConverter.cs
│ │ │ ├── KeyValuePairConverter.cs
│ │ │ ├── RegexConverter.cs
│ │ │ ├── StringEnumConverter.cs
│ │ │ ├── UnixDateTimeConverter.cs
│ │ │ ├── VersionConverter.cs
│ │ │ └── XmlNodeConverter.cs
│ │ ├── DateFormatHandling.cs
│ │ ├── DateParseHandling.cs
│ │ ├── DateTimeZoneHandling.cs
│ │ ├── DefaultJsonNameTable.cs
│ │ ├── DefaultValueHandling.cs
│ │ ├── Dynamic.snk
│ │ ├── FloatFormatHandling.cs
│ │ ├── FloatParseHandling.cs
│ │ ├── FormatterAssemblyStyle.cs
│ │ ├── Formatting.cs
│ │ ├── IArrayPool.cs
│ │ ├── IJsonLineInfo.cs
│ │ ├── JsonArrayAttribute.cs
│ │ ├── JsonConstructorAttribute.cs
│ │ ├── JsonContainerAttribute.cs
│ │ ├── JsonConvert.cs
│ │ ├── JsonConverter.cs
│ │ ├── JsonConverterAttribute.cs
│ │ ├── JsonConverterCollection.cs
│ │ ├── JsonDictionaryAttribute.cs
│ │ ├── JsonException.cs
│ │ ├── JsonExtensionDataAttribute.cs
│ │ ├── JsonIgnoreAttribute.cs
│ │ ├── JsonNameTable.cs
│ │ ├── JsonObjectAttribute.cs
│ │ ├── JsonPosition.cs
│ │ ├── JsonPropertyAttribute.cs
│ │ ├── JsonReader.Async.cs
│ │ ├── JsonReader.cs
│ │ ├── JsonReaderException.cs
│ │ ├── JsonRequiredAttribute.cs
│ │ ├── JsonSerializationException.cs
│ │ ├── JsonSerializer.cs
│ │ ├── JsonSerializerSettings.cs
│ │ ├── JsonTextReader.Async.cs
│ │ ├── JsonTextReader.cs
│ │ ├── JsonTextWriter.Async.cs
│ │ ├── JsonTextWriter.cs
│ │ ├── JsonToken.cs
│ │ ├── JsonValidatingReader.cs
│ │ ├── JsonWriter.Async.cs
│ │ ├── JsonWriter.cs
│ │ ├── JsonWriterException.cs
│ │ ├── Linq/
│ │ │ ├── CommentHandling.cs
│ │ │ ├── DuplicatePropertyNameHandling.cs
│ │ │ ├── Extensions.cs
│ │ │ ├── IJEnumerable.cs
│ │ │ ├── JArray.Async.cs
│ │ │ ├── JArray.cs
│ │ │ ├── JConstructor.Async.cs
│ │ │ ├── JConstructor.cs
│ │ │ ├── JContainer.Async.cs
│ │ │ ├── JContainer.cs
│ │ │ ├── JEnumerable.cs
│ │ │ ├── JObject.Async.cs
│ │ │ ├── JObject.cs
│ │ │ ├── JProperty.Async.cs
│ │ │ ├── JProperty.cs
│ │ │ ├── JPropertyDescriptor.cs
│ │ │ ├── JPropertyKeyedCollection.cs
│ │ │ ├── JRaw.Async.cs
│ │ │ ├── JRaw.cs
│ │ │ ├── JToken.Async.cs
│ │ │ ├── JToken.cs
│ │ │ ├── JTokenEqualityComparer.cs
│ │ │ ├── JTokenReader.cs
│ │ │ ├── JTokenType.cs
│ │ │ ├── JTokenWriter.Async.cs
│ │ │ ├── JTokenWriter.cs
│ │ │ ├── JValue.Async.cs
│ │ │ ├── JValue.cs
│ │ │ ├── JsonCloneSettings.cs
│ │ │ ├── JsonLoadSettings.cs
│ │ │ ├── JsonMergeSettings.cs
│ │ │ ├── JsonPath/
│ │ │ │ ├── ArrayIndexFilter.cs
│ │ │ │ ├── ArrayMultipleIndexFilter.cs
│ │ │ │ ├── ArraySliceFilter.cs
│ │ │ │ ├── FieldFilter.cs
│ │ │ │ ├── FieldMultipleFilter.cs
│ │ │ │ ├── JPath.cs
│ │ │ │ ├── PathFilter.cs
│ │ │ │ ├── QueryExpression.cs
│ │ │ │ ├── QueryFilter.cs
│ │ │ │ ├── QueryScanFilter.cs
│ │ │ │ ├── RootFilter.cs
│ │ │ │ ├── ScanFilter.cs
│ │ │ │ └── ScanMultipleFilter.cs
│ │ │ ├── JsonSelectSettings.cs
│ │ │ ├── LineInfoHandling.cs
│ │ │ ├── MergeArrayHandling.cs
│ │ │ └── MergeNullValueHandling.cs
│ │ ├── MemberSerialization.cs
│ │ ├── MetadataPropertyHandling.cs
│ │ ├── MissingMemberHandling.cs
│ │ ├── Newtonsoft.Json.csproj
│ │ ├── Newtonsoft.Json.ruleset
│ │ ├── NullValueHandling.cs
│ │ ├── ObjectCreationHandling.cs
│ │ ├── PreserveReferencesHandling.cs
│ │ ├── Properties/
│ │ │ └── AssemblyInfo.cs
│ │ ├── README.md
│ │ ├── ReferenceLoopHandling.cs
│ │ ├── Required.cs
│ │ ├── Schema/
│ │ │ ├── Extensions.cs
│ │ │ ├── JsonSchema.cs
│ │ │ ├── JsonSchemaBuilder.cs
│ │ │ ├── JsonSchemaConstants.cs
│ │ │ ├── JsonSchemaException.cs
│ │ │ ├── JsonSchemaGenerator.cs
│ │ │ ├── JsonSchemaModel.cs
│ │ │ ├── JsonSchemaModelBuilder.cs
│ │ │ ├── JsonSchemaNode.cs
│ │ │ ├── JsonSchemaNodeCollection.cs
│ │ │ ├── JsonSchemaResolver.cs
│ │ │ ├── JsonSchemaType.cs
│ │ │ ├── JsonSchemaWriter.cs
│ │ │ ├── UndefinedSchemaIdHandling.cs
│ │ │ ├── ValidationEventArgs.cs
│ │ │ └── ValidationEventHandler.cs
│ │ ├── Serialization/
│ │ │ ├── CachedAttributeGetter.cs
│ │ │ ├── CamelCaseNamingStrategy.cs
│ │ │ ├── CamelCasePropertyNamesContractResolver.cs
│ │ │ ├── DefaultContractResolver.cs
│ │ │ ├── DefaultNamingStrategy.cs
│ │ │ ├── DefaultReferenceResolver.cs
│ │ │ ├── DefaultSerializationBinder.cs
│ │ │ ├── DiagnosticsTraceWriter.cs
│ │ │ ├── DynamicValueProvider.cs
│ │ │ ├── ErrorContext.cs
│ │ │ ├── ErrorEventArgs.cs
│ │ │ ├── ExpressionValueProvider.cs
│ │ │ ├── FormatterConverter.cs
│ │ │ ├── IAttributeProvider.cs
│ │ │ ├── IContractResolver.cs
│ │ │ ├── IReferenceResolver.cs
│ │ │ ├── ISerializationBinder.cs
│ │ │ ├── ITraceWriter.cs
│ │ │ ├── IValueProvider.cs
│ │ │ ├── JsonArrayContract.cs
│ │ │ ├── JsonContainerContract.cs
│ │ │ ├── JsonContract.cs
│ │ │ ├── JsonDictionaryContract.cs
│ │ │ ├── JsonDynamicContract.cs
│ │ │ ├── JsonFormatterConverter.cs
│ │ │ ├── JsonISerializableContract.cs
│ │ │ ├── JsonLinqContract.cs
│ │ │ ├── JsonObjectContract.cs
│ │ │ ├── JsonPrimitiveContract.cs
│ │ │ ├── JsonProperty.cs
│ │ │ ├── JsonPropertyCollection.cs
│ │ │ ├── JsonSerializerInternalBase.cs
│ │ │ ├── JsonSerializerInternalReader.cs
│ │ │ ├── JsonSerializerInternalWriter.cs
│ │ │ ├── JsonSerializerProxy.cs
│ │ │ ├── JsonStringContract.cs
│ │ │ ├── JsonTypeReflector.cs
│ │ │ ├── KebabCaseNamingStrategy.cs
│ │ │ ├── MemoryTraceWriter.cs
│ │ │ ├── NamingStrategy.cs
│ │ │ ├── ObjectConstructor.cs
│ │ │ ├── OnErrorAttribute.cs
│ │ │ ├── ReflectionAttributeProvider.cs
│ │ │ ├── ReflectionValueProvider.cs
│ │ │ ├── SerializationBinderAdapter.cs
│ │ │ ├── SnakeCaseNamingStrategy.cs
│ │ │ ├── TraceJsonReader.cs
│ │ │ └── TraceJsonWriter.cs
│ │ ├── SerializationBinder.cs
│ │ ├── StringEscapeHandling.cs
│ │ ├── TraceLevel.cs
│ │ ├── TypeNameAssemblyFormatHandling.cs
│ │ ├── TypeNameHandling.cs
│ │ ├── Utilities/
│ │ │ ├── AsyncUtils.cs
│ │ │ ├── Base64Encoder.cs
│ │ │ ├── BidirectionalDictionary.cs
│ │ │ ├── BoxedPrimitives.cs
│ │ │ ├── CollectionUtils.cs
│ │ │ ├── CollectionWrapper.cs
│ │ │ ├── ConvertUtils.cs
│ │ │ ├── DateTimeParser.cs
│ │ │ ├── DateTimeUtils.cs
│ │ │ ├── DictionaryWrapper.cs
│ │ │ ├── DynamicProxy.cs
│ │ │ ├── DynamicProxyMetaObject.cs
│ │ │ ├── DynamicReflectionDelegateFactory.cs
│ │ │ ├── DynamicUtils.cs
│ │ │ ├── DynamicallyAccessedMemberTypes.cs
│ │ │ ├── DynamicallyAccessedMembersAttribute.cs
│ │ │ ├── EnumInfo.cs
│ │ │ ├── EnumUtils.cs
│ │ │ ├── ExpressionReflectionDelegateFactory.cs
│ │ │ ├── FSharpUtils.cs
│ │ │ ├── FeatureGuardAttribute.cs
│ │ │ ├── FeatureSwitchDefinitionAttribute.cs
│ │ │ ├── ILGeneratorExtensions.cs
│ │ │ ├── ImmutableCollectionsUtils.cs
│ │ │ ├── JavaScriptUtils.cs
│ │ │ ├── JsonTokenUtils.cs
│ │ │ ├── LateBoundReflectionDelegateFactory.cs
│ │ │ ├── LinqBridge.cs
│ │ │ ├── MathUtils.cs
│ │ │ ├── MethodBinder.cs
│ │ │ ├── MethodCall.cs
│ │ │ ├── MiscellaneousUtils.cs
│ │ │ ├── NullableAttributes.cs
│ │ │ ├── ReflectionDelegateFactory.cs
│ │ │ ├── ReflectionObject.cs
│ │ │ ├── ReflectionUtils.cs
│ │ │ ├── RequiresDynamicCodeAttribute.cs
│ │ │ ├── RequiresUnreferencedCodeAttribute.cs
│ │ │ ├── StringBuffer.cs
│ │ │ ├── StringReference.cs
│ │ │ ├── StringUtils.cs
│ │ │ ├── StructMultiKey.cs
│ │ │ ├── ThreadSafeStore.cs
│ │ │ ├── TypeExtensions.cs
│ │ │ ├── UnconditionalSuppressMessageAttribute.cs
│ │ │ └── ValidationUtils.cs
│ │ └── WriteState.cs
│ ├── Newtonsoft.Json.FuzzTests/
│ │ ├── FuzzTests.cs
│ │ └── Newtonsoft.Json.FuzzTests.csproj
│ ├── Newtonsoft.Json.TestConsole/
│ │ ├── App.config
│ │ ├── Newtonsoft.Json.TestConsole.csproj
│ │ └── Program.cs
│ ├── Newtonsoft.Json.Tests/
│ │ ├── App.config
│ │ ├── Benchmarks/
│ │ │ ├── BenchmarkConstants.cs
│ │ │ ├── DeserializeBenchmarks.cs
│ │ │ ├── DeserializeComparisonBenchmarks.cs
│ │ │ ├── JTokenBenchmarks.cs
│ │ │ ├── JValueConvertBenchmarks.cs
│ │ │ ├── JsonTextReaderBenchmarks.cs
│ │ │ ├── JsonTextWriterBenchmarks.cs
│ │ │ ├── LargeJArrayBenchmarks.cs
│ │ │ ├── LowLevelBenchmarks.cs
│ │ │ ├── Runner.cs
│ │ │ ├── SerializeBenchmarks.cs
│ │ │ ├── SerializeComparisonBenchmarks.cs
│ │ │ └── XmlNodeConverterBenchmarks.cs
│ │ ├── Bson/
│ │ │ ├── BsonReaderAsyncTests.cs
│ │ │ ├── BsonReaderTests.cs
│ │ │ ├── BsonWriterAsyncTests.cs
│ │ │ └── BsonWriterTests.cs
│ │ ├── Converters/
│ │ │ ├── BinaryConverterTests.cs
│ │ │ ├── CustomCreationConverterTests.cs
│ │ │ ├── DataSetConverterTests.cs
│ │ │ ├── DataTableConverterTests.cs
│ │ │ ├── DiscriminatedUnionConverterTests.cs
│ │ │ ├── ExpandoObjectConverterTests.cs
│ │ │ ├── GenericJsonConverterTests.cs
│ │ │ ├── IsoDateTimeConverterTests.cs
│ │ │ ├── JavaScriptDateTimeConverterTests.cs
│ │ │ ├── KeyValuePairConverterTests.cs
│ │ │ ├── ObjectIdConverterTests.cs
│ │ │ ├── RegexConverterTests.cs
│ │ │ ├── StringEnumConverterTests.cs
│ │ │ ├── UnixDateTimeConverterTests.cs
│ │ │ ├── VersionConverterTests.cs
│ │ │ └── XmlNodeConverterTest.cs
│ │ ├── DemoTests.cs
│ │ ├── Documentation/
│ │ │ ├── ConditionalPropertiesTests.cs
│ │ │ ├── ConvertingJsonAndXmlTests.cs
│ │ │ ├── JsonSchemaTests.cs
│ │ │ ├── LinqToJsonTests.cs
│ │ │ ├── PerformanceTests.cs
│ │ │ ├── ReadingAndWritingJsonTests.cs
│ │ │ ├── Samples/
│ │ │ │ ├── Bson/
│ │ │ │ │ ├── DeserializeFromBson.cs
│ │ │ │ │ ├── DeserializeFromBsonCollection.cs
│ │ │ │ │ └── SerializeToBson.cs
│ │ │ │ ├── Json/
│ │ │ │ │ ├── CustomJsonReader.cs
│ │ │ │ │ ├── CustomJsonWriter.cs
│ │ │ │ │ ├── ReadJsonWithJsonTextReader.cs
│ │ │ │ │ ├── ReadMultipleContentWithJsonReader.cs
│ │ │ │ │ └── WriteJsonWithJsonTextWriter.cs
│ │ │ │ ├── JsonPath/
│ │ │ │ │ ├── ErrorWhenNoMatchQuery.cs
│ │ │ │ │ ├── QueryJsonSelectToken.cs
│ │ │ │ │ ├── QueryJsonSelectTokenEscaped.cs
│ │ │ │ │ ├── QueryJsonSelectTokenJsonPath.cs
│ │ │ │ │ ├── QueryJsonSelectTokenWithLinq.cs
│ │ │ │ │ ├── RegexQuery.cs
│ │ │ │ │ └── StrictEqualsQuery.cs
│ │ │ │ ├── Linq/
│ │ │ │ │ ├── Clone.cs
│ │ │ │ │ ├── CreateJsonAnonymousObject.cs
│ │ │ │ │ ├── CreateJsonCollectionInitializer.cs
│ │ │ │ │ ├── CreateJsonDeclaratively.cs
│ │ │ │ │ ├── CreateJsonDynamic.cs
│ │ │ │ │ ├── CreateJsonJTokenWriter.cs
│ │ │ │ │ ├── CreateJsonManually.cs
│ │ │ │ │ ├── CreateReader.cs
│ │ │ │ │ ├── CreateWriter.cs
│ │ │ │ │ ├── DeepEquals.cs
│ │ │ │ │ ├── DeserializeWithLinq.cs
│ │ │ │ │ ├── FromObject.cs
│ │ │ │ │ ├── JObjectProperties.cs
│ │ │ │ │ ├── JTokenAnnotation.cs
│ │ │ │ │ ├── JValueCast.cs
│ │ │ │ │ ├── JValueValue.cs
│ │ │ │ │ ├── MergeJson.cs
│ │ │ │ │ ├── ModifyJson.cs
│ │ │ │ │ ├── ParseJsonAny.cs
│ │ │ │ │ ├── ParseJsonArray.cs
│ │ │ │ │ ├── ParseJsonObject.cs
│ │ │ │ │ ├── QueryJson.cs
│ │ │ │ │ ├── QueryJsonDynamic.cs
│ │ │ │ │ ├── QueryJsonIgnoreCase.cs
│ │ │ │ │ ├── QueryJsonLinq.cs
│ │ │ │ │ ├── ReadJTokenFromBson.cs
│ │ │ │ │ ├── ReadJson.cs
│ │ │ │ │ ├── SerializeWithLinq.cs
│ │ │ │ │ ├── ToObjectComplex.cs
│ │ │ │ │ ├── ToObjectGeneric.cs
│ │ │ │ │ ├── ToObjectType.cs
│ │ │ │ │ ├── ToString.cs
│ │ │ │ │ ├── ToStringJsonConverter.cs
│ │ │ │ │ ├── WriteJTokenToBson.cs
│ │ │ │ │ └── WriteToJsonFile.cs
│ │ │ │ ├── Schema/
│ │ │ │ │ ├── CreateJsonSchemaManually.cs
│ │ │ │ │ ├── JTokenIsValid.cs
│ │ │ │ │ ├── JTokenIsValidWithMessages.cs
│ │ │ │ │ ├── JTokenValidateWithEvent.cs
│ │ │ │ │ ├── JsonSchemaParse.cs
│ │ │ │ │ ├── JsonValidatingReaderAndSerializer.cs
│ │ │ │ │ ├── LoadJsonSchemaFromFile.cs
│ │ │ │ │ ├── RefJsonSchemaResolver.cs
│ │ │ │ │ └── SaveJsonSchemaToFile.cs
│ │ │ │ ├── Serializer/
│ │ │ │ │ ├── CustomContractResolver.cs
│ │ │ │ │ ├── CustomJsonConverter.cs
│ │ │ │ │ ├── CustomJsonConverterGeneric.cs
│ │ │ │ │ ├── CustomTraceWriter.cs
│ │ │ │ │ ├── DataContractAndDataMember.cs
│ │ │ │ │ ├── DefaultSettings.cs
│ │ │ │ │ ├── DefaultValueAttributeIgnore.cs
│ │ │ │ │ ├── DefaultValueHandlingIgnore.cs
│ │ │ │ │ ├── DeserializeAnonymousType.cs
│ │ │ │ │ ├── DeserializeCollection.cs
│ │ │ │ │ ├── DeserializeConstructorHandling.cs
│ │ │ │ │ ├── DeserializeCustomCreationConverter.cs
│ │ │ │ │ ├── DeserializeDataSet.cs
│ │ │ │ │ ├── DeserializeDateFormatString.cs
│ │ │ │ │ ├── DeserializeDictionary.cs
│ │ │ │ │ ├── DeserializeExtensionData.cs
│ │ │ │ │ ├── DeserializeImmutableCollections.cs
│ │ │ │ │ ├── DeserializeMetadataPropertyHandling.cs
│ │ │ │ │ ├── DeserializeMissingMemberHandling.cs
│ │ │ │ │ ├── DeserializeObject.cs
│ │ │ │ │ ├── DeserializeObjectCreationHandling.cs
│ │ │ │ │ ├── DeserializeWithDependencyInjection.cs
│ │ │ │ │ ├── DeserializeWithJsonSerializerFromFile.cs
│ │ │ │ │ ├── ErrorHandlingAttribute.cs
│ │ │ │ │ ├── ErrorHandlingEvent.cs
│ │ │ │ │ ├── JsonConstructorAttribute.cs
│ │ │ │ │ ├── JsonConverterAttributeClass.cs
│ │ │ │ │ ├── JsonConverterAttributeProperty.cs
│ │ │ │ │ ├── JsonObjectAttributeOptIn.cs
│ │ │ │ │ ├── JsonObjectAttributeOverrideIEnumerable.cs
│ │ │ │ │ ├── JsonPropertyItemLevelSetting.cs
│ │ │ │ │ ├── JsonPropertyName.cs
│ │ │ │ │ ├── JsonPropertyOrder.cs
│ │ │ │ │ ├── JsonPropertyPropertyLevelSetting.cs
│ │ │ │ │ ├── JsonPropertyRequired.cs
│ │ │ │ │ ├── MaxDepth.cs
│ │ │ │ │ ├── NamingStrategyAttributes.cs
│ │ │ │ │ ├── NamingStrategyCamelCase.cs
│ │ │ │ │ ├── NamingStrategyKebabCase.cs
│ │ │ │ │ ├── NamingStrategySkipDictionaryKeys.cs
│ │ │ │ │ ├── NamingStrategySkipSpecifiedNames.cs
│ │ │ │ │ ├── NamingStrategySnakeCase.cs
│ │ │ │ │ ├── NullValueHandlingIgnore.cs
│ │ │ │ │ ├── PopulateObject.cs
│ │ │ │ │ ├── PreserveReferencesHandlingObject.cs
│ │ │ │ │ ├── PropertyJsonIgnore.cs
│ │ │ │ │ ├── ReferenceLoopHandlingIgnore.cs
│ │ │ │ │ ├── SerializationCallbackAttributes.cs
│ │ │ │ │ ├── SerializeCollection.cs
│ │ │ │ │ ├── SerializeConditionalProperty.cs
│ │ │ │ │ ├── SerializeContractResolver.cs
│ │ │ │ │ ├── SerializeDataSet.cs
│ │ │ │ │ ├── SerializeDateFormatHandling.cs
│ │ │ │ │ ├── SerializeDateFormatString.cs
│ │ │ │ │ ├── SerializeDateTimeZoneHandling.cs
│ │ │ │ │ ├── SerializeDictionary.cs
│ │ │ │ │ ├── SerializeExtensionData.cs
│ │ │ │ │ ├── SerializeImmutableCollections.cs
│ │ │ │ │ ├── SerializeObject.cs
│ │ │ │ │ ├── SerializeRawJson.cs
│ │ │ │ │ ├── SerializeSerializationBinder.cs
│ │ │ │ │ ├── SerializeTypeNameHandling.cs
│ │ │ │ │ ├── SerializeUnindentedJson.cs
│ │ │ │ │ ├── SerializeWithJsonConverters.cs
│ │ │ │ │ ├── SerializeWithJsonSerializerToFile.cs
│ │ │ │ │ └── TraceWriter.cs
│ │ │ │ └── Xml/
│ │ │ │ ├── ConvertJsonToXml.cs
│ │ │ │ ├── ConvertXmlToJson.cs
│ │ │ │ └── ConvertXmlToJsonForceArray.cs
│ │ │ ├── SerializationTests.cs
│ │ │ └── TraceWriterTests.cs
│ │ ├── ExceptionTests.cs
│ │ ├── FileSystemEntityModel.Designer.cs
│ │ ├── FileSystemEntityModel.edmx
│ │ ├── FuzzRegressionTests.cs
│ │ ├── Issues/
│ │ │ ├── Issue0198.cs
│ │ │ ├── Issue0573.cs
│ │ │ ├── Issue1307.cs
│ │ │ ├── Issue1321.cs
│ │ │ ├── Issue1322.cs
│ │ │ ├── Issue1327.cs
│ │ │ ├── Issue1351.cs
│ │ │ ├── Issue1353.cs
│ │ │ ├── Issue1362.cs
│ │ │ ├── Issue1396.cs
│ │ │ ├── Issue1404.cs
│ │ │ ├── Issue1445.cs
│ │ │ ├── Issue1460.cs
│ │ │ ├── Issue1461.cs
│ │ │ ├── Issue1512.cs
│ │ │ ├── Issue1541.cs
│ │ │ ├── Issue1545.cs
│ │ │ ├── Issue1552.cs
│ │ │ ├── Issue1561.cs
│ │ │ ├── Issue1566.cs
│ │ │ ├── Issue1569.cs
│ │ │ ├── Issue1574.cs
│ │ │ ├── Issue1576.cs
│ │ │ ├── Issue1592.cs
│ │ │ ├── Issue1593.cs
│ │ │ ├── Issue1597.cs
│ │ │ ├── Issue1598.cs
│ │ │ ├── Issue1619.cs
│ │ │ ├── Issue1620.cs
│ │ │ ├── Issue1642.cs
│ │ │ ├── Issue1682.cs
│ │ │ ├── Issue1708.cs
│ │ │ ├── Issue1711.cs
│ │ │ ├── Issue1719.cs
│ │ │ ├── Issue1725.cs
│ │ │ ├── Issue1734.cs
│ │ │ ├── Issue1752.cs
│ │ │ ├── Issue1757.cs
│ │ │ ├── Issue1778.cs
│ │ │ ├── Issue1796.cs
│ │ │ ├── Issue1798.cs
│ │ │ ├── Issue1834.cs
│ │ │ ├── Issue1837.cs
│ │ │ ├── Issue1874.cs
│ │ │ ├── Issue1877.cs
│ │ │ ├── Issue1962.cs
│ │ │ ├── Issue1984.cs
│ │ │ ├── Issue2082.cs
│ │ │ ├── Issue2156.cs
│ │ │ ├── Issue2165.cs
│ │ │ ├── Issue2176.cs
│ │ │ ├── Issue2444.cs
│ │ │ ├── Issue2450.cs
│ │ │ ├── Issue2484.cs
│ │ │ ├── Issue2492.cs
│ │ │ ├── Issue2504.cs
│ │ │ ├── Issue2529.cs
│ │ │ ├── Issue2638.cs
│ │ │ ├── Issue2694.cs
│ │ │ ├── Issue2708.cs
│ │ │ ├── Issue2735.cs
│ │ │ ├── Issue2768.cs
│ │ │ ├── Issue2775.cs
│ │ │ ├── Issue3055.cs
│ │ │ ├── Issue3056.cs
│ │ │ └── Issue3080.cs
│ │ ├── JsonArrayAttributeTests.cs
│ │ ├── JsonConvertTest.cs
│ │ ├── JsonTextReaderTests/
│ │ │ ├── ExceptionHandlingAsyncTests.cs
│ │ │ ├── ExceptionHandlingTests.cs
│ │ │ ├── FloatAsyncTests.cs
│ │ │ ├── FloatTests.cs
│ │ │ ├── MiscAsyncTests.cs
│ │ │ ├── MiscTests.cs
│ │ │ ├── ParseAsyncTests.cs
│ │ │ ├── ParseTests.cs
│ │ │ ├── ReadAsyncTests.cs
│ │ │ └── ReadTests.cs
│ │ ├── JsonTextWriterAsyncTests.cs
│ │ ├── JsonTextWriterTest.cs
│ │ ├── JsonValidatingReaderTests.cs
│ │ ├── Linq/
│ │ │ ├── AnnotationsTests.cs
│ │ │ ├── ComponentModel/
│ │ │ │ ├── BindingTests.cs
│ │ │ │ └── JPropertyDescriptorTests.cs
│ │ │ ├── DynamicTests.cs
│ │ │ ├── JArrayTests.cs
│ │ │ ├── JConstructorAsyncTests.cs
│ │ │ ├── JConstructorTests.cs
│ │ │ ├── JObjectAsyncTests.cs
│ │ │ ├── JObjectTests.cs
│ │ │ ├── JPropertyAsyncTests.cs
│ │ │ ├── JPropertyTests.cs
│ │ │ ├── JRawTests.cs
│ │ │ ├── JTokenAsyncTests.cs
│ │ │ ├── JTokenEqualityComparerTests.cs
│ │ │ ├── JTokenReaderAsyncTests.cs
│ │ │ ├── JTokenReaderTest.cs
│ │ │ ├── JTokenTests.cs
│ │ │ ├── JTokenWriterAsyncTests.cs
│ │ │ ├── JTokenWriterTest.cs
│ │ │ ├── JValueAsyncTests.cs
│ │ │ ├── JValueTests.cs
│ │ │ ├── JsonPath/
│ │ │ │ ├── JPathExecuteTests.cs
│ │ │ │ ├── JPathParseTests.cs
│ │ │ │ └── QueryExpressionTests.cs
│ │ │ ├── LinqToJsonAsyncTests.cs
│ │ │ ├── LinqToJsonTest.cs
│ │ │ └── MergeTests.cs
│ │ ├── LinqToSql/
│ │ │ ├── Department.cs
│ │ │ ├── DepartmentConverter.cs
│ │ │ ├── GuidByteArrayConverter.cs
│ │ │ ├── LinqToSqlClasses.dbml
│ │ │ ├── LinqToSqlClasses.dbml.layout
│ │ │ ├── LinqToSqlClasses.designer.cs
│ │ │ ├── LinqToSqlClassesSerializationTests.cs
│ │ │ ├── Person.cs
│ │ │ └── Role.cs
│ │ ├── Newtonsoft.Json.Tests.csproj
│ │ ├── PoisonText.txt
│ │ ├── Properties/
│ │ │ └── AssemblyInfo.cs
│ │ ├── Schema/
│ │ │ ├── ExtensionsTests.cs
│ │ │ ├── JsonSchemaBuilderTests.cs
│ │ │ ├── JsonSchemaGeneratorTests.cs
│ │ │ ├── JsonSchemaModelBuilderTests.cs
│ │ │ ├── JsonSchemaNodeTests.cs
│ │ │ ├── JsonSchemaSpecTests.cs
│ │ │ ├── JsonSchemaTests.cs
│ │ │ ├── PerformanceTests.cs
│ │ │ └── Specs/
│ │ │ ├── additionalItems.json
│ │ │ ├── additionalProperties.json
│ │ │ ├── dependencies.json
│ │ │ ├── disallow.json
│ │ │ ├── divisibleBy.json
│ │ │ ├── enum.json
│ │ │ ├── extends.json
│ │ │ ├── items.json
│ │ │ ├── maxItems.json
│ │ │ ├── maxLength.json
│ │ │ ├── maximum.json
│ │ │ ├── minItems.json
│ │ │ ├── minLength.json
│ │ │ ├── minimum.json
│ │ │ ├── pattern.json
│ │ │ ├── patternProperties.json
│ │ │ ├── properties.json
│ │ │ ├── ref.json
│ │ │ ├── required.json
│ │ │ ├── type.json
│ │ │ └── uniqueItems.json
│ │ ├── Serialization/
│ │ │ ├── CamelCaseNamingStrategyTests.cs
│ │ │ ├── CamelCasePropertyNamesContractResolverTests.cs
│ │ │ ├── ConstructorHandlingTests.cs
│ │ │ ├── ContractResolverTests.cs
│ │ │ ├── DateOnlyTests.cs
│ │ │ ├── DateTimeZoneHandlingTests.cs
│ │ │ ├── DefaultValueHandlingTests.cs
│ │ │ ├── DependencyInjectionTests.cs
│ │ │ ├── DynamicConcreteTests.cs
│ │ │ ├── DynamicTests.cs
│ │ │ ├── EntitiesSerializationTests.cs
│ │ │ ├── ExtensionDataTests.cs
│ │ │ ├── FSharpTests.cs
│ │ │ ├── ImmutableCollectionsTests.cs
│ │ │ ├── JsonPropertyCollectionTests.cs
│ │ │ ├── JsonSerializerCollectionsTests.cs
│ │ │ ├── JsonSerializerTest.cs
│ │ │ ├── KebabCaseNamingStrategyTests.cs
│ │ │ ├── MetadataPropertyHandlingTests.cs
│ │ │ ├── MissingMemberHandlingTests.cs
│ │ │ ├── NamingStrategyEquality.cs
│ │ │ ├── NullValueHandlingTests.cs
│ │ │ ├── PopulateTests.cs
│ │ │ ├── PreserveReferencesHandlingTests.cs
│ │ │ ├── ReferenceLoopHandlingTests.cs
│ │ │ ├── ReflectionAttributeProviderTests.cs
│ │ │ ├── SerializationErrorHandlingTests.cs
│ │ │ ├── SerializationEventAttributeTests.cs
│ │ │ ├── ShouldSerializeTests.cs
│ │ │ ├── SnakeCaseNamingStrategyTests.cs
│ │ │ ├── TimeOnlyTests.cs
│ │ │ ├── TraceWriterTests.cs
│ │ │ ├── TypeNameHandlingTests.cs
│ │ │ └── WebApiIntegrationTests.cs
│ │ ├── SpaceShipV2.bson
│ │ ├── TestFixtureBase.cs
│ │ ├── TestObjects/
│ │ │ ├── A.cs
│ │ │ ├── AATestClass.cs
│ │ │ ├── Aa.cs
│ │ │ ├── AbstractDictionaryTestClass.cs
│ │ │ ├── AbstractGenericBase.cs
│ │ │ ├── AbstractImplementationDictionaryTestClass.cs
│ │ │ ├── AbstractImplementationListTestClass.cs
│ │ │ ├── AbstractImplementationTestClass.cs
│ │ │ ├── AbstractListTestClass.cs
│ │ │ ├── AbstractTestClass.cs
│ │ │ ├── Address.cs
│ │ │ ├── Animal.cs
│ │ │ ├── AnswerFilterModel.cs
│ │ │ ├── Antworten.cs
│ │ │ ├── ArgumentConverterPrecedenceClassConverter.cs
│ │ │ ├── Article.cs
│ │ │ ├── ArticleCollection.cs
│ │ │ ├── AttachmentReadConverter.cs
│ │ │ ├── B.cs
│ │ │ ├── BBTestClass.cs
│ │ │ ├── BadJsonPropertyClass.cs
│ │ │ ├── Bar.cs
│ │ │ ├── Bar1.cs
│ │ │ ├── BaseClass.cs
│ │ │ ├── BaseClassVirtual.cs
│ │ │ ├── BaseClassWithProtectedVirtual.cs
│ │ │ ├── BaseConstructorType.cs
│ │ │ ├── BaseDataContract.cs
│ │ │ ├── BaseDataContractWithHidden.cs
│ │ │ ├── BaseType.cs
│ │ │ ├── BaseWithContract.cs
│ │ │ ├── BaseWithPrivate.cs
│ │ │ ├── BaseWithoutContract.cs
│ │ │ ├── Bb.cs
│ │ │ ├── Binding.cs
│ │ │ ├── Binding_DisallowNull.cs
│ │ │ ├── BusRun.cs
│ │ │ ├── ByteArrayTestClass.cs
│ │ │ ├── Car.cs
│ │ │ ├── ChildClass.cs
│ │ │ ├── ChildClassVirtual.cs
│ │ │ ├── ChildClassWithProtectedOverridePlusJsonProperty.cs
│ │ │ ├── ChildDataContractWithHidden.cs
│ │ │ ├── CircularConstructor1.cs
│ │ │ ├── CircularConstructor2.cs
│ │ │ ├── CircularReferenceClass.cs
│ │ │ ├── CircularReferenceWithIdClass.cs
│ │ │ ├── ClassAndMemberConverterClass.cs
│ │ │ ├── ClassAttributeBase.cs
│ │ │ ├── ClassAttributeDerived.cs
│ │ │ ├── ClassConverterPrecedenceClassConverter.cs
│ │ │ ├── ClassWithArray.cs
│ │ │ ├── ClassWithException.cs
│ │ │ ├── ClassWithGuid.cs
│ │ │ ├── ClassWithImplicitOperator.cs
│ │ │ ├── ClassWithTimeSpan.cs
│ │ │ ├── ClientMap.cs
│ │ │ ├── CollectionClassAttributeDerived.cs
│ │ │ ├── CommentTestClass.cs
│ │ │ ├── CommentTestObject.cs
│ │ │ ├── CompletionDataRequest.cs
│ │ │ ├── ComplexItem.cs
│ │ │ ├── Component.cs
│ │ │ ├── Computer.cs
│ │ │ ├── ConsoleWriter.cs
│ │ │ ├── ConstantTestClass.cs
│ │ │ ├── ConstructorAndDefaultValueAttributeTestClass.cs
│ │ │ ├── ConstructorAndRequiredTestClass.cs
│ │ │ ├── ConstructorCaseSensitivityClass.cs
│ │ │ ├── ConstructorCompexIgnoredProperty.cs
│ │ │ ├── ConstructorReadonlyFields.cs
│ │ │ ├── Container.cs
│ │ │ ├── Content.cs
│ │ │ ├── ContentBaseClass.cs
│ │ │ ├── ContentSubClass.cs
│ │ │ ├── ConverableMembers.cs
│ │ │ ├── ConvertableIntTestClass.cs
│ │ │ ├── ConverterPrecedenceClass.cs
│ │ │ ├── ConverterPrecedenceClassConverter.cs
│ │ │ ├── ConvertibleId.cs
│ │ │ ├── ConvertibleInt.cs
│ │ │ ├── CustomerDataSet.cs
│ │ │ ├── CustomerWithMetadataType.cs
│ │ │ ├── DTOWithParameterisedConstructor.cs
│ │ │ ├── DTOWithoutParameterisedConstructor.cs
│ │ │ ├── DataContractJsonSerializerTestClass.cs
│ │ │ ├── DataContractPrivateMembers.cs
│ │ │ ├── DataContractSerializationAttributesClass.cs
│ │ │ ├── DateTimeErrorObjectCollection.cs
│ │ │ ├── DateTimeOffsetTestClass.cs
│ │ │ ├── DateTimeOffsetWrapper.cs
│ │ │ ├── DateTimeTestClass.cs
│ │ │ ├── DateTimeWrapper.cs
│ │ │ ├── DecimalTest.cs
│ │ │ ├── DecimalTestClass.cs
│ │ │ ├── DefaultValueAttributeTestClass.cs
│ │ │ ├── DerivedConstructorType.cs
│ │ │ ├── DerivedEvent.cs
│ │ │ ├── DerivedSerializationEventTestObject.cs
│ │ │ ├── DerivedType.cs
│ │ │ ├── DerivedWithPrivate.cs
│ │ │ ├── DeserializeStringConvert.cs
│ │ │ ├── DictionaryInterfaceClass.cs
│ │ │ ├── DictionaryKey.cs
│ │ │ ├── DictionaryKeyCast.cs
│ │ │ ├── DictionaryKeyContractResolver.cs
│ │ │ ├── DictionaryWithNoDefaultConstructor.cs
│ │ │ ├── DictionaryWithNoNull.cs
│ │ │ ├── DirectoryAccount.cs
│ │ │ ├── DoubleClass.cs
│ │ │ ├── EmployeeReference.cs
│ │ │ ├── EmptyJsonValueTestClass.cs
│ │ │ ├── EncodingReadConverter.cs
│ │ │ ├── EnumA.cs
│ │ │ ├── EnumerableArrayPropertyClass.cs
│ │ │ ├── EnumerableClass.cs
│ │ │ ├── ErroringClass.cs
│ │ │ ├── ErroringJsonConverter.cs
│ │ │ ├── ErroringTestClass.cs
│ │ │ ├── Events/
│ │ │ │ ├── Event.cs
│ │ │ │ ├── Event1.cs
│ │ │ │ └── EventType.cs
│ │ │ ├── ExistingValueClass.cs
│ │ │ ├── FaqItem.cs
│ │ │ ├── Foo.cs
│ │ │ ├── Foo1.cs
│ │ │ ├── Foo64.cs
│ │ │ ├── FooBar1.cs
│ │ │ ├── FooConstructor.cs
│ │ │ ├── FooRequired.cs
│ │ │ ├── Friend.cs
│ │ │ ├── GameObject.cs
│ │ │ ├── GenericIEnumerableWithImplicitConversion.cs
│ │ │ ├── GenericImpl.cs
│ │ │ ├── GenericListAndDictionaryInterfaceProperties.cs
│ │ │ ├── GeoCoding/
│ │ │ │ ├── AddressDetails.cs
│ │ │ │ ├── AdministrativeArea.cs
│ │ │ │ ├── Country.cs
│ │ │ │ ├── GoogleMapGeocoderStructure.cs
│ │ │ │ ├── Locality.cs
│ │ │ │ ├── Placemark.cs
│ │ │ │ ├── Point.cs
│ │ │ │ ├── PostalCode.cs
│ │ │ │ ├── Status.cs
│ │ │ │ ├── SubAdministrativeArea.cs
│ │ │ │ └── Thoroughfare.cs
│ │ │ ├── GeometricForms/
│ │ │ │ ├── Shape.cs
│ │ │ │ └── Tags.cs
│ │ │ ├── GetOnlyPropertyClass.cs
│ │ │ ├── HasByteArray.cs
│ │ │ ├── HolderClass.cs
│ │ │ ├── Human.cs
│ │ │ ├── IInterfaceObject.cs
│ │ │ ├── IKeyValueId.cs
│ │ │ ├── IMainClass.cs
│ │ │ ├── IMyInterface.cs
│ │ │ ├── IPrivateImplementationA.cs
│ │ │ ├── IPrivateImplementationB.cs
│ │ │ ├── IPrivateOverriddenImplementation.cs
│ │ │ ├── ISerializableTestObject.cs
│ │ │ ├── ISerializableWithoutAttributeTestObject.cs
│ │ │ ├── ISubclass.cs
│ │ │ ├── ISubclassBase.cs
│ │ │ ├── IdReferenceResolver.cs
│ │ │ ├── IgnoreDataMemberTestClass.cs
│ │ │ ├── IgnoredPropertiesContractResolver.cs
│ │ │ ├── IgnoredPropertiesTestClass.cs
│ │ │ ├── IgnoredProperty.cs
│ │ │ ├── ImmutableStruct.cs
│ │ │ ├── ImplementInterfaceObject.cs
│ │ │ ├── IncompatibleJsonAttributeClass.cs
│ │ │ ├── IncompleteTestClass.cs
│ │ │ ├── IntToFloatConverter.cs
│ │ │ ├── InterfacePropertyTestClass.cs
│ │ │ ├── Invoice.cs
│ │ │ ├── Item.cs
│ │ │ ├── ItemBase.cs
│ │ │ ├── ItemConverterTestClass.cs
│ │ │ ├── ItemConverterTestConverter.cs
│ │ │ ├── JRawValueTestObject.cs
│ │ │ ├── JTokenTestClass.cs
│ │ │ ├── JaggedArray.cs
│ │ │ ├── JsonIgnoreAttributeOnClassTestClass.cs
│ │ │ ├── JsonIgnoreAttributeTestClass.cs
│ │ │ ├── JsonPropertyClass.cs
│ │ │ ├── JsonPropertyConverterContractResolver.cs
│ │ │ ├── JsonPropertyConverterTestClass.cs
│ │ │ ├── JsonPropertyWithHandlingValues.cs
│ │ │ ├── JsonReaderStubWithIsClosed.cs
│ │ │ ├── JsonTextReaderTests/
│ │ │ │ ├── FakeArrayPool.cs
│ │ │ │ ├── SlowStream.cs
│ │ │ │ ├── ToggleReaderError.cs
│ │ │ │ └── UnmanagedResourceFakingJsonReader.cs
│ │ │ ├── KVPair.cs
│ │ │ ├── KeyValueId.cs
│ │ │ ├── KeyValueTestClass.cs
│ │ │ ├── Link.cs
│ │ │ ├── ListErrorObject.cs
│ │ │ ├── ListErrorObjectCollection.cs
│ │ │ ├── ListOfIds.cs
│ │ │ ├── ListSourceTest.cs
│ │ │ ├── ListTestClass.cs
│ │ │ ├── LogEntry.cs
│ │ │ ├── LogEvent.cs
│ │ │ ├── MailAddressReadConverter.cs
│ │ │ ├── MainClass.cs
│ │ │ ├── MemberConverterClass.cs
│ │ │ ├── MemberConverterPrecedenceClassConverter.cs
│ │ │ ├── MessageWithIsoDate.cs
│ │ │ ├── MethodExecutorObject.cs
│ │ │ ├── MetroColorConverter.cs
│ │ │ ├── MetroPropertyNameResolver.cs
│ │ │ ├── MetroStringConverter.cs
│ │ │ ├── ModelStateDictionary.cs
│ │ │ ├── Money/
│ │ │ │ ├── Currency.cs
│ │ │ │ └── Tags.cs
│ │ │ ├── Movie.cs
│ │ │ ├── MovieWithJsonObjectNullValueHandlingIgnore.cs
│ │ │ ├── MovieWithJsonObjectNullValueHandlingInclude.cs
│ │ │ ├── MultiIndexBase.cs
│ │ │ ├── MultiIndexSuper.cs
│ │ │ ├── MultipleItemsClass.cs
│ │ │ ├── MultipleParametrizedConstructorsJsonConstructor.cs
│ │ │ ├── MyClass.cs
│ │ │ ├── MyEnum.cs
│ │ │ ├── MyFactory.cs
│ │ │ ├── MyInterfaceConverter.cs
│ │ │ ├── MyObservableObject.cs
│ │ │ ├── MyTuple.cs
│ │ │ ├── MyTuplePartial.cs
│ │ │ ├── Name.cs
│ │ │ ├── NameContainer.cs
│ │ │ ├── NameContainerConverter.cs
│ │ │ ├── NoConstructorReadOnlyCollection.cs
│ │ │ ├── NoConstructorReadOnlyDictionary.cs
│ │ │ ├── NonDefaultConstructorWithReadOnlyCollectionProperty.cs
│ │ │ ├── NonDefaultConstructorWithReadOnlyDictionaryProperty.cs
│ │ │ ├── NonPublicConstructorWithJsonConstructor.cs
│ │ │ ├── NonRequest.cs
│ │ │ ├── NullTestClass.cs
│ │ │ ├── NullableDateTimeTestClass.cs
│ │ │ ├── NullableFloats.cs
│ │ │ ├── NullableGuid.cs
│ │ │ ├── NullableGuidCountingJsonTextWriter.cs
│ │ │ ├── NullableLongTestClass.cs
│ │ │ ├── NullableStructPropertyClass.cs
│ │ │ ├── NullableTestClass.cs
│ │ │ ├── ObjectArrayPropertyTest.cs
│ │ │ ├── ObservableObject.cs
│ │ │ ├── OptInClass.cs
│ │ │ ├── Organization/
│ │ │ │ ├── Employee.cs
│ │ │ │ ├── IPerson.cs
│ │ │ │ ├── Manager.cs
│ │ │ │ ├── Person.cs
│ │ │ │ ├── PersonPropertyClass.cs
│ │ │ │ └── WagePerson.cs
│ │ │ ├── Pair.cs
│ │ │ ├── ParticipantEntity.cs
│ │ │ ├── PersonConverter.cs
│ │ │ ├── PersonError.cs
│ │ │ ├── PersonRaw.cs
│ │ │ ├── PersonReference.cs
│ │ │ ├── PersonSerializable.cs
│ │ │ ├── PersonWithPrivateConstructor.cs
│ │ │ ├── PhoneNumber.cs
│ │ │ ├── PocoDataContractSerializationAttributesClass.cs
│ │ │ ├── Pos.cs
│ │ │ ├── PosConverter.cs
│ │ │ ├── PosDouble.cs
│ │ │ ├── PosDoubleConverter.cs
│ │ │ ├── PreserveReferencesCallbackTestObject.cs
│ │ │ ├── PrivateConstructorTestClass.cs
│ │ │ ├── PrivateConstructorWithPublicParameterizedConstructorTestClass.cs
│ │ │ ├── PrivateImplementationAClass.cs
│ │ │ ├── PrivateImplementationBClass.cs
│ │ │ ├── PrivateMembersClass.cs
│ │ │ ├── PrivateMembersClassWithAttributes.cs
│ │ │ ├── PrivateSetterBase.cs
│ │ │ ├── PrivateSetterDerived.cs
│ │ │ ├── Product.cs
│ │ │ ├── ProductCollection.cs
│ │ │ ├── ProductShort.cs
│ │ │ ├── PropertyCase.cs
│ │ │ ├── PropertyItemConverter.cs
│ │ │ ├── PublicConstructorOverridenByJsonConstructor.cs
│ │ │ ├── PublicParameterizedConstructorRequiringConverterTestClass.cs
│ │ │ ├── PublicParameterizedConstructorRequiringConverterWithParameterAttributeTestClass.cs
│ │ │ ├── PublicParameterizedConstructorRequiringConverterWithPropertyAttributeTestClass.cs
│ │ │ ├── PublicParameterizedConstructorTestClass.cs
│ │ │ ├── PublicParameterizedConstructorWithNonPropertyParameterTestClass.cs
│ │ │ ├── PublicParameterizedConstructorWithPropertyNameConflict.cs
│ │ │ ├── PublicParameterizedConstructorWithPropertyNameConflictWithAttribute.cs
│ │ │ ├── Ratio.cs
│ │ │ ├── ReflectionContractResolver.cs
│ │ │ ├── RequestOnly.cs
│ │ │ ├── RequiredMembersClass.cs
│ │ │ ├── RequiredObject.cs
│ │ │ ├── RequiredPropertyConstructorTestClass.cs
│ │ │ ├── RequiredPropertyTestClass.cs
│ │ │ ├── ResponseWithNewGenericProperty.cs
│ │ │ ├── ResponseWithNewGenericPropertyOverride.cs
│ │ │ ├── ResponseWithNewGenericPropertyVirtual.cs
│ │ │ ├── RoleTransfer.cs
│ │ │ ├── RoleTransferDirection.cs
│ │ │ ├── RoleTransferOperation.cs
│ │ │ ├── RootObject.cs
│ │ │ ├── SearchResult.cs
│ │ │ ├── SelectListItem.cs
│ │ │ ├── SerializableContractResolver.cs
│ │ │ ├── SerializationEventTestDictionary.cs
│ │ │ ├── SerializationEventTestList.cs
│ │ │ ├── SerializationEventTestObject.cs
│ │ │ ├── SerializationEventTestObjectWithConstructor.cs
│ │ │ ├── SetOnlyPropertyClass.cs
│ │ │ ├── SetOnlyPropertyClass2.cs
│ │ │ ├── Shortie.cs
│ │ │ ├── SimpleResponse.cs
│ │ │ ├── SqlTypesDataSet.Designer.cs
│ │ │ ├── SqlTypesDataSet.xsc
│ │ │ ├── SqlTypesDataSet.xsd
│ │ │ ├── SqlTypesDataSet.xss
│ │ │ ├── StaticTestClass.cs
│ │ │ ├── Store.cs
│ │ │ ├── StoreColor.cs
│ │ │ ├── StringDictionaryTestClass.cs
│ │ │ ├── StructISerializable.cs
│ │ │ ├── StructTest.cs
│ │ │ ├── StructWithAttribute.cs
│ │ │ ├── SubKlass.cs
│ │ │ ├── SubWithContractNewProperties.cs
│ │ │ ├── SubWithContractVirtualProperties.cs
│ │ │ ├── SubWithoutContractNewProperties.cs
│ │ │ ├── SubWithoutContractVirtualProperties.cs
│ │ │ ├── Subclass.cs
│ │ │ ├── SuperKlass.cs
│ │ │ ├── Test.cs
│ │ │ ├── TestClass.cs
│ │ │ ├── TestClassConvertable.cs
│ │ │ ├── TestComponent.cs
│ │ │ ├── TestComponentSimple.cs
│ │ │ ├── TestObject.cs
│ │ │ ├── ThisGenericTest.cs
│ │ │ ├── TimeZoneOffsetObject.cs
│ │ │ ├── TraceWriter.cs
│ │ │ ├── TypeClass.cs
│ │ │ ├── TypeConverterJsonConverter.cs
│ │ │ ├── TypeConverterSize.cs
│ │ │ ├── TypeConverterSizeConverter.cs
│ │ │ ├── TypedSubHashtable.cs
│ │ │ ├── UriGuidTimeSpanTestClass.cs
│ │ │ ├── UserNullable.cs
│ │ │ ├── Vector.cs
│ │ │ ├── VectorParent.cs
│ │ │ ├── VersionKeyedCollection.cs
│ │ │ ├── VersionOld.cs
│ │ │ ├── VirtualOverrideNewBaseObject.cs
│ │ │ ├── VirtualOverrideNewChildObject.cs
│ │ │ ├── VirtualOverrideNewChildWithDifferentOverrideObject.cs
│ │ │ ├── Widget.cs
│ │ │ ├── Widget1.cs
│ │ │ ├── WidgetId.cs
│ │ │ ├── WidgetId1.cs
│ │ │ ├── WidgetIdJsonConverter.cs
│ │ │ ├── WithEnums.cs
│ │ │ ├── XNodeTestObject.cs
│ │ │ └── XmlNodeTestObject.cs
│ │ ├── Utilities/
│ │ │ ├── ConvertUtilsTests.cs
│ │ │ ├── DateTimeUtilsTests.cs
│ │ │ ├── DynamicReflectionDelegateFactoryTests.cs
│ │ │ ├── EnumUtilsTests.cs
│ │ │ ├── ExpressionReflectionDelegateFactoryTests.cs
│ │ │ ├── LateboundReflectionDelegateFactoryTests.cs
│ │ │ ├── ReflectionUtilsTests.cs
│ │ │ └── StringUtilsTests.cs
│ │ ├── large.json
│ │ └── large_sample.xml
│ ├── Newtonsoft.Json.slnx
│ ├── NuGet.Config
│ └── global.json
└── azure-pipelines.yml
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitattributes
================================================
*.doc diff=astextplain
*.DOC diff=astextplain
*.docx diff=astextplain
*.DOCX diff=astextplain
*.dot diff=astextplain
*.DOT diff=astextplain
*.pdf diff=astextplain
*.PDF diff=astextplain
*.rtf diff=astextplain
*.RTF diff=astextplain
*.jpg binary
*.png binary
*.gif binary
*.bson binary
*.cs text diff=csharp
*.vb text
*.c text
*.cpp text
*.cxx text
*.h text
*.hxx text
*.py text
*.rb text
*.java text
*.html text
*.htm text
*.css text
*.scss text
*.sass text
*.less text
*.js text
*.lisp text
*.clj text
*.sql text
*.php text
*.lua text
*.m text
*.asm text
*.erl text
*.fs text
*.fsx text
*.hs text
*.ps1 text
*.psm1 text
*.csproj text merge=union
*.vbproj text merge=union
*.fsproj text merge=union
*.dbproj text merge=union
*.sln text eol=crlf merge=union
================================================
FILE: .github/workflows/codeql.yml
================================================
# For most projects, this workflow file will not need changing; you simply need
# to commit it to your repository.
#
# You may wish to alter this file to override the set of languages analyzed,
# or to provide custom queries or build logic.
#
# ******** NOTE ********
# We have attempted to detect the languages in your repository. Please check
# the `language` matrix defined below to confirm you have the correct set of
# supported CodeQL languages.
#
name: "CodeQL Advanced"
on:
push:
branches: [ "master" ]
pull_request:
branches: [ "master" ]
schedule:
- cron: '42 20 * * 6'
jobs:
analyze:
name: Analyze (${{ matrix.language }})
# Runner size impacts CodeQL analysis time. To learn more, please see:
# - https://gh.io/recommended-hardware-resources-for-running-codeql
# - https://gh.io/supported-runners-and-hardware-resources
# - https://gh.io/using-larger-runners (GitHub.com only)
# Consider using larger runners or machines with greater resources for possible analysis time improvements.
runs-on: ${{ (matrix.language == 'swift' && 'macos-latest') || 'ubuntu-latest' }}
permissions:
# required for all workflows
security-events: write
# required to fetch internal or private CodeQL packs
packages: read
# only required for workflows in private repositories
actions: read
contents: read
strategy:
fail-fast: false
matrix:
include:
- language: csharp
build-mode: autobuild
# CodeQL supports the following values keywords for 'language': 'c-cpp', 'csharp', 'go', 'java-kotlin', 'javascript-typescript', 'python', 'ruby', 'swift'
# Use `c-cpp` to analyze code written in C, C++ or both
# Use 'java-kotlin' to analyze code written in Java, Kotlin or both
# Use 'javascript-typescript' to analyze code written in JavaScript, TypeScript or both
# To learn more about changing the languages that are analyzed or customizing the build mode for your analysis,
# see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/customizing-your-advanced-setup-for-code-scanning.
# If you are analyzing a compiled language, you can modify the 'build-mode' for that language to customize how
# your codebase is analyzed, see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages
steps:
- name: Checkout repository
uses: actions/checkout@v4
# Add any setup steps before running the `github/codeql-action/init` action.
# This includes steps like installing compilers or runtimes (`actions/setup-node`
# or others). This is typically only required for manual builds.
# - name: Setup runtime (example)
# uses: actions/setup-example@v1
# Initializes the CodeQL tools for scanning.
- name: Initialize CodeQL
uses: github/codeql-action/init@v3
with:
languages: ${{ matrix.language }}
build-mode: ${{ matrix.build-mode }}
# If you wish to specify custom queries, you can do so here or in a config file.
# By default, queries listed here will override any specified in a config file.
# Prefix the list here with "+" to use these queries and those in the config file.
# For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
# queries: security-extended,security-and-quality
# If the analyze step fails for one of the languages you are analyzing with
# "We were unable to automatically build your code", modify the matrix above
# to set the build mode to "manual" for that language. Then modify this step
# to build your code.
# ℹ️ Command-line programs to run using the OS shell.
# 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
- if: matrix.build-mode == 'manual'
shell: bash
run: |
echo 'If you are using a "manual" build mode for one or more of the' \
'languages you are analyzing, replace this with the commands to build' \
'your code, for example:'
echo ' make bootstrap'
echo ' make release'
exit 1
- name: Perform CodeQL Analysis
uses: github/codeql-action/analyze@v3
with:
category: "/language:${{matrix.language}}"
================================================
FILE: .gitignore
================================================
[Bb]in/
[Oo]bj/
[Ww]orking*/
Build/Temp/
Doc/doc.shfbproj_*
TestResults/
AppPackages/
BenchmarkDotNet.Artifacts/
*.suo
*.user
*.userprefs
_ReSharper.*
*.ReSharper.user
*.resharper.user
.vs/
.vscode/
*.lock.json
*.nuget.props
*.nuget.targets
*.orig
.DS_Store
================================================
FILE: Build/Sign-Package.ps1
================================================
$currentDirectory = split-path $MyInvocation.MyCommand.Definition
# See if we have the SignKeyVaultCertificate available
if ([string]::IsNullOrEmpty($Env:SignKeyVaultCertificate)){
Write-Host "Key vault detail not found, not signing packages"
return;
}
dotnet tool install --tool-path . --prerelease sign
$files = gci $Env:ArtifactDirectory\*.nupkg,*.zip -recurse | Select -ExpandProperty FullName
$signKeyVaultCertificate = $Env:SignKeyVaultCertificate
$signKeyVaultUrl = $Env:SignKeyVaultUrl
foreach ($file in $files){
Write-Host "Submitting $file for signing"
.\sign code azure-key-vault $file `
--publisher-name "Newtonsoft" `
--description "Json.NET" `
--description-url "https://www.newtonsoft.com/json" `
--azure-key-vault-certificate $signKeyVaultCertificate `
--azure-key-vault-url $signKeyVaultUrl
Write-Host "Finished signing $file"
}
Write-Host "Sign-package complete"
================================================
FILE: Build/appsettings.json
================================================
{
"SignClient": {
"AzureAd": {
"AADInstance": "https://login.microsoftonline.com/",
"ClientId": "c248d68a-ba6f-4aa9-8a68-71fe872063f8",
"TenantId": "16076fdc-fcc1-4a15-b1ca-32c9a255900e"
},
"Service": {
"Url": "https://codesign.dotnetfoundation.org/",
"ResourceId": "https://SignService/3c30251f-36f3-490b-a955-520addb85001"
}
}
}
================================================
FILE: Build/build.ps1
================================================
properties {
$zipFileName = "Json130r5.zip"
$majorVersion = "13.0"
$majorWithReleaseVersion = "13.0.5"
$nugetPrerelease = $null
$version = GetVersion $majorWithReleaseVersion
$packageId = "Newtonsoft.Json"
$signAssemblies = $false
$signKeyPath = "C:\Development\Releases\newtonsoft.snk"
$buildDocumentation = $false
$buildNuGet = $true
$msbuildVerbosity = 'minimal'
$treatWarningsAsErrors = $false
$workingName = if ($workingName) {$workingName} else {"Working"}
$assemblyVersion = if ($assemblyVersion) {$assemblyVersion} else {$majorVersion + '.0.0'}
$netCliChannel = "STS"
$netCliVersion = "9.0.300"
$nugetUrl = "https://dist.nuget.org/win-x86-commandline/latest/nuget.exe"
$ensureNetCliSdk = $true
$baseDir = resolve-path ..
$buildDir = "$baseDir\Build"
$sourceDir = "$baseDir\Src"
$docDir = "$baseDir\Doc"
$releaseDir = "$baseDir\Release"
$workingDir = "$baseDir\$workingName"
$nugetPath = "$buildDir\Temp\nuget.exe"
$vswhereVersion = "3.1.7"
$vswherePath = "$buildDir\Temp\vswhere.$vswhereVersion"
$nunitConsoleVersion = "3.8.0"
$nunitConsolePath = "$buildDir\Temp\NUnit.ConsoleRunner.$nunitConsoleVersion"
$builds = @(
@{Framework = "net6.0"; TestsFunction = "NetCliTests"; TestFramework = "net6.0"; Enabled=$true},
@{Framework = "netstandard2.0"; TestsFunction = "NetCliTests"; TestFramework = "net5.0"; Enabled=$true},
@{Framework = "netstandard1.3"; TestsFunction = "NetCliTests"; TestFramework = "netcoreapp3.1"; Enabled=$true},
@{Framework = "netstandard1.0"; TestsFunction = "NetCliTests"; TestFramework = "netcoreapp2.1"; Enabled=$true},
@{Framework = "net45"; TestsFunction = "NUnitTests"; TestFramework = "net46"; NUnitFramework="net-4.0"; Enabled=$true},
@{Framework = "net40"; TestsFunction = "NUnitTests"; NUnitFramework="net-4.0"; Enabled=$true},
@{Framework = "net35"; TestsFunction = "NUnitTests"; NUnitFramework="net-2.0"; Enabled=$true},
@{Framework = "net20"; TestsFunction = "NUnitTests"; NUnitFramework="net-2.0"; Enabled=$true}
)
}
framework '4.6x86'
task default -depends Test,Package
# Ensure a clean working directory
task Clean {
Write-Host "Setting location to $baseDir"
Set-Location $baseDir
if (Test-Path -path $workingDir)
{
Write-Host "Deleting existing working directory $workingDir"
Execute-Command -command { del $workingDir -Recurse -Force }
}
Write-Host "Creating working directory $workingDir"
New-Item -Path $workingDir -ItemType Directory
}
# Build each solution, optionally signed
task Build -depends Clean {
$script:enabledBuilds = $builds | ? {$_.Enabled}
Write-Host -ForegroundColor Green "Found $($script:enabledBuilds.Length) enabled builds"
mkdir "$buildDir\Temp" -Force
if ($ensureNetCliSdk)
{
EnsureDotNetCli
}
EnsureNuGetExists
EnsureNuGetPackage "vswhere" $vswherePath $vswhereVersion
EnsureNuGetPackage "NUnit.ConsoleRunner" $nunitConsolePath $nunitConsoleVersion
$script:msBuildPath = GetMsBuildPath
Write-Host "MSBuild path $script:msBuildPath"
NetCliBuild
}
# Optional build documentation, add files to final zip
task Package -depends Build {
foreach ($build in $script:enabledBuilds)
{
$finalDir = $build.Framework
$sourcePath = "$sourceDir\Newtonsoft.Json\bin\Release\$finalDir"
if (!(Test-Path -path $sourcePath))
{
throw "Could not find $sourcePath"
}
robocopy $sourcePath $workingDir\Package\Bin\$finalDir *.dll *.pdb *.xml /NFL /NDL /NJS /NC /NS /NP /XO /XF *.CodeAnalysisLog.xml | Out-Default
}
if ($buildNuGet)
{
Write-Host -ForegroundColor Green "Copy NuGet package"
mkdir $workingDir\NuGet
move -Path $sourceDir\Newtonsoft.Json\bin\Release\*.nupkg -Destination $workingDir\NuGet
move -Path $sourceDir\Newtonsoft.Json\bin\Release\*.snupkg -Destination $workingDir\NuGet
}
Write-Host "Build documentation: $buildDocumentation"
if ($buildDocumentation)
{
$mainBuild = $script:enabledBuilds | where { $_.Framework -eq "net45" } | select -first 1
$mainBuildFinalDir = $mainBuild.Framework
$documentationSourcePath = "$workingDir\Package\Bin\$mainBuildFinalDir"
$docOutputPath = "$workingDir\Documentation\"
Write-Host -ForegroundColor Green "Building documentation from $documentationSourcePath"
Write-Host "Documentation output to $docOutputPath"
# Sandcastle has issues when compiling with .NET 4 MSBuild
exec { & $script:msBuildPath "/t:Clean;Rebuild" "/v:$msbuildVerbosity" "/p:Configuration=Release" "/p:DocumentationSourcePath=$documentationSourcePath" "/p:OutputPath=$docOutputPath" "/m" "$docDir\doc.shfbproj" | Out-Default } "Error building documentation. Check that you have Sandcastle, Sandcastle Help File Builder and HTML Help Workshop installed."
move -Path $workingDir\Documentation\LastBuild.log -Destination $workingDir\Documentation.log
}
Copy-Item -Path $docDir\readme.txt -Destination $workingDir\Package\
Copy-Item -Path $docDir\license.txt -Destination $workingDir\Package\
robocopy $sourceDir $workingDir\Package\Source\Src /MIR /NFL /NDL /NJS /NC /NS /NP /XD bin obj TestResults AppPackages .vs artifacts /XF *.suo *.user *.lock.json | Out-Default
robocopy $buildDir $workingDir\Package\Source\Build /MIR /NFL /NDL /NJS /NC /NS /NP /XD Temp /XF runbuild.txt | Out-Default
robocopy $docDir $workingDir\Package\Source\Doc /MIR /NFL /NDL /NJS /NC /NS /NP | Out-Default
# include fuzz tests in ADO pipeline artifacts
mkdir $workingDir\FuzzTests
Copy-Item -Path $sourceDir\Newtonsoft.Json.FuzzTests\bin\Release\net6.0\* -Destination $workingDir\FuzzTests
Compress-Archive -Path $workingDir\Package\* -DestinationPath $workingDir\$zipFileName
}
task Test -depends Build {
foreach ($build in $script:enabledBuilds)
{
Write-Host "Calling $($build.TestsFunction)"
& $build.TestsFunction $build
}
}
function NetCliBuild()
{
$projectPath = "$sourceDir\Newtonsoft.Json.slnx"
$libraryFrameworks = ($script:enabledBuilds | Select-Object @{Name="Framework";Expression={$_.Framework}} | select -expand Framework) -join ";"
$testFrameworks = ($script:enabledBuilds | Select-Object @{Name="Resolved";Expression={if ($_.TestFramework -ne $null) { $_.TestFramework } else { $_.Framework }}} | select -expand Resolved) -join ";"
$additionalConstants = switch($signAssemblies) { $true { "SIGNED" } default { "" } }
Write-Host -ForegroundColor Green "Restoring packages for $libraryFrameworks in $projectPath"
Write-Host
exec { & $script:msBuildPath "/t:restore" "/v:$msbuildVerbosity" "/p:Configuration=Release" "/p:LibraryFrameworks=`"$libraryFrameworks`"" "/p:TestFrameworks=`"$testFrameworks`"" "/m" $projectPath | Out-Default } "Error restoring $projectPath"
Write-Host -ForegroundColor Green "Building $libraryFrameworks $assemblyVersion in $projectPath"
Write-Host
exec { & $script:msBuildPath "/t:build" "/v:$msbuildVerbosity" $projectPath "/p:Configuration=Release" "/p:LibraryFrameworks=`"$libraryFrameworks`"" "/p:TestFrameworks=`"$testFrameworks`"" "/p:AssemblyOriginatorKeyFile=$signKeyPath" "/p:SignAssembly=$signAssemblies" "/p:TreatWarningsAsErrors=$treatWarningsAsErrors" "/p:AdditionalConstants=$additionalConstants" "/p:GeneratePackageOnBuild=$buildNuGet" "/p:ContinuousIntegrationBuild=true" "/p:PackageId=$packageId" "/p:VersionPrefix=$majorWithReleaseVersion" "/p:VersionSuffix=$nugetPrerelease" "/p:AssemblyVersion=$assemblyVersion" "/p:FileVersion=$version" "/m" }
}
function EnsureDotnetCli()
{
Write-Host "Downloading dotnet-install.ps1"
# https://stackoverflow.com/questions/36265534/invoke-webrequest-ssl-fails
[Net.ServicePointManager]::SecurityProtocol = 'TLS12'
Invoke-WebRequest `
-Uri "https://dot.net/v1/dotnet-install.ps1" `
-OutFile "$buildDir\Temp\dotnet-install.ps1"
exec { & $buildDir\Temp\dotnet-install.ps1 -Channel $netCliChannel -Version $netCliVersion | Out-Default }
exec { & $buildDir\Temp\dotnet-install.ps1 -Channel $netCliChannel -Version '6.0.400' | Out-Default }
exec { & $buildDir\Temp\dotnet-install.ps1 -Channel $netCliChannel -Version '3.1.402' | Out-Default }
exec { & $buildDir\Temp\dotnet-install.ps1 -Channel $netCliChannel -Version '2.1.818' | Out-Default }
}
function EnsureNuGetExists()
{
if (!(Test-Path $nugetPath))
{
Write-Host "Couldn't find nuget.exe. Downloading from $nugetUrl to $nugetPath"
(New-Object System.Net.WebClient).DownloadFile($nugetUrl, $nugetPath)
}
}
function EnsureNuGetPackage($packageName, $packagePath, $packageVersion)
{
if (!(Test-Path $packagePath))
{
Write-Host "Couldn't find $packagePath. Downloading with NuGet"
exec { & $nugetPath install $packageName -OutputDirectory $buildDir\Temp -Version $packageVersion -ConfigFile "$sourceDir\nuget.config" | Out-Default } "Error restoring $packagePath"
}
}
function GetMsBuildPath()
{
$path = & $vswherePath\tools\vswhere.exe -latest -prerelease -products * -requires Microsoft.Component.MSBuild -property installationPath
if (!($path))
{
throw "Could not find Visual Studio install path"
}
$msBuildPath = join-path $path 'MSBuild\15.0\Bin\MSBuild.exe'
if (Test-Path $msBuildPath)
{
return $msBuildPath
}
$msBuildPath = join-path $path 'MSBuild\Current\Bin\MSBuild.exe'
if (Test-Path $msBuildPath)
{
return $msBuildPath
}
throw "Could not find MSBuild path"
}
function NetCliTests($build)
{
$projectPath = "$sourceDir\Newtonsoft.Json.Tests\Newtonsoft.Json.Tests.csproj"
$location = "$sourceDir\Newtonsoft.Json.Tests"
$testDir = if ($build.TestFramework -ne $null) { $build.TestFramework } else { $build.Framework }
try
{
Set-Location $location
exec { dotnet --version | Out-Default }
Write-Host -ForegroundColor Green "Running tests for $testDir"
Write-Host "Location: $location"
Write-Host "Project path: $projectPath"
Write-Host
exec { dotnet test $projectPath -f $testDir -c Release -l trx --results-directory $workingDir --no-restore --no-build | Out-Default }
}
finally
{
Set-Location $baseDir
}
}
function NUnitTests($build)
{
$testDir = if ($build.TestFramework -ne $null) { $build.TestFramework } else { $build.Framework }
$framework = $build.NUnitFramework
$testRunDir = "$sourceDir\Newtonsoft.Json.Tests\bin\Release\$testDir"
Write-Host -ForegroundColor Green "Running NUnit tests $testDir"
Write-Host
try
{
Set-Location $testRunDir
exec { & $nunitConsolePath\tools\nunit3-console.exe "$testRunDir\Newtonsoft.Json.Tests.dll" --framework=$framework --result=$workingDir\$testDir.xml --out=$workingDir\$testDir.txt | Out-Default } "Error running $testDir tests"
}
finally
{
Set-Location $baseDir
}
}
function GetVersion($majorVersion)
{
$now = [DateTime]::Now
$year = $now.Year - 2000
$month = $now.Month
$totalMonthsSince2000 = ($year * 12) + $month
$day = $now.Day
$minor = "{0}{1:00}" -f $totalMonthsSince2000, $day
$hour = $now.Hour
$minute = $now.Minute
$revision = "{0:00}{1:00}" -f $hour, $minute
return $majorVersion + "." + $minor
}
function Edit-XmlNodes {
param (
[xml] $doc,
[string] $xpath = $(throw "xpath is a required parameter"),
[string] $value = $(throw "value is a required parameter")
)
$nodes = $doc.SelectNodes($xpath)
$count = $nodes.Count
Write-Host "Found $count nodes with path '$xpath'"
foreach ($node in $nodes) {
if ($node -ne $null) {
if ($node.NodeType -eq "Element")
{
$node.InnerXml = $value
}
else
{
$node.Value = $value
}
}
}
}
function Execute-Command($command) {
$currentRetry = 0
$success = $false
do {
try
{
& $command
$success = $true
}
catch [System.Exception]
{
if ($currentRetry -gt 5) {
throw $_.Exception.ToString()
} else {
write-host "Retry $currentRetry"
Start-Sleep -s 1
}
$currentRetry = $currentRetry + 1
}
} while (!$success)
}
================================================
FILE: Build/localbuild.ps1
================================================
Start-Transcript ($PSScriptRoot + '\Temp\runbuild.txt')
$version = Get-Content "$PSScriptRoot\version.json" | Out-String | ConvertFrom-Json
& $PSScriptRoot\runbuild.ps1 -properties @{"majorVersion"="$($version.Major).0"; "majorWithReleaseVersion"="$($version.Major).0.$($version.Release)"; "nugetPrerelease"=$version.Prerelease; "zipFileName"="Json$($version.Major)0r$($version.Release).zip"; "treatWarningsAsErrors"=$true}
================================================
FILE: Build/psake.psm1
================================================
# psake
# Copyright (c) 2012 James Kovacs
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#Requires -Version 2.0
#-- Public Module Functions --#
# .ExternalHelp psake.psm1-help.xml
function Invoke-Task
{
[CmdletBinding()]
param(
[Parameter(Position=0,Mandatory=1)] [string]$taskName
)
Assert $taskName ($msgs.error_invalid_task_name)
$taskKey = $taskName.ToLower()
if ($currentContext.aliases.Contains($taskKey)) {
$taskName = $currentContext.aliases.$taskKey.Name
$taskKey = $taskName.ToLower()
}
$currentContext = $psake.context.Peek()
Assert ($currentContext.tasks.Contains($taskKey)) ($msgs.error_task_name_does_not_exist -f $taskName)
if ($currentContext.executedTasks.Contains($taskKey)) { return }
Assert (!$currentContext.callStack.Contains($taskKey)) ($msgs.error_circular_reference -f $taskName)
$currentContext.callStack.Push($taskKey)
$task = $currentContext.tasks.$taskKey
$precondition_is_valid = & $task.Precondition
if (!$precondition_is_valid) {
WriteColoredOutput ($msgs.precondition_was_false -f $taskName) -foregroundcolor Cyan
} else {
if ($taskKey -ne 'default') {
if ($task.PreAction -or $task.PostAction) {
Assert ($task.Action -ne $null) ($msgs.error_missing_action_parameter -f $taskName)
}
if ($task.Action) {
try {
foreach($childTask in $task.DependsOn) {
Invoke-Task $childTask
}
$stopwatch = [System.Diagnostics.Stopwatch]::StartNew()
$currentContext.currentTaskName = $taskName
& $currentContext.taskSetupScriptBlock
if ($task.PreAction) {
& $task.PreAction
}
if ($currentContext.config.taskNameFormat -is [ScriptBlock]) {
& $currentContext.config.taskNameFormat $taskName
} else {
WriteColoredOutput ($currentContext.config.taskNameFormat -f $taskName) -foregroundcolor Cyan
}
foreach ($variable in $task.requiredVariables) {
Assert ((test-path "variable:$variable") -and ((get-variable $variable).Value -ne $null)) ($msgs.required_variable_not_set -f $variable, $taskName)
}
& $task.Action
if ($task.PostAction) {
& $task.PostAction
}
& $currentContext.taskTearDownScriptBlock
$task.Duration = $stopwatch.Elapsed
} catch {
if ($task.ContinueOnError) {
"-"*70
WriteColoredOutput ($msgs.continue_on_error -f $taskName,$_) -foregroundcolor Yellow
"-"*70
$task.Duration = $stopwatch.Elapsed
} else {
throw $_
}
}
} else {
# no action was specified but we still execute all the dependencies
foreach($childTask in $task.DependsOn) {
Invoke-Task $childTask
}
}
} else {
foreach($childTask in $task.DependsOn) {
Invoke-Task $childTask
}
}
Assert (& $task.Postcondition) ($msgs.postcondition_failed -f $taskName)
}
$poppedTaskKey = $currentContext.callStack.Pop()
Assert ($poppedTaskKey -eq $taskKey) ($msgs.error_corrupt_callstack -f $taskKey,$poppedTaskKey)
$currentContext.executedTasks.Push($taskKey)
}
# .ExternalHelp psake.psm1-help.xml
function Exec
{
[CmdletBinding()]
param(
[Parameter(Position=0,Mandatory=1)][scriptblock]$cmd,
[Parameter(Position=1,Mandatory=0)][string]$errorMessage = ($msgs.error_bad_command -f $cmd),
[Parameter(Position=2,Mandatory=0)][int]$maxRetries = 0,
[Parameter(Position=3,Mandatory=0)][string]$retryTriggerErrorPattern = $null
)
$tryCount = 1
do {
try {
$global:lastexitcode = 0
& $cmd
if ($lastexitcode -ne 0) {
throw ("Exec: " + $errorMessage)
}
break
}
catch [Exception]
{
if ($tryCount -gt $maxRetries) {
throw $_
}
if ($retryTriggerErrorPattern -ne $null) {
$isMatch = [regex]::IsMatch($_.Exception.Message, $retryTriggerErrorPattern)
if ($isMatch -eq $false) {
throw $_
}
}
Write-Host "Try $tryCount failed, retrying again in 1 second..."
$tryCount++
[System.Threading.Thread]::Sleep([System.TimeSpan]::FromSeconds(1))
}
}
while ($true)
}
# .ExternalHelp psake.psm1-help.xml
function Assert
{
[CmdletBinding()]
param(
[Parameter(Position=0,Mandatory=1)]$conditionToCheck,
[Parameter(Position=1,Mandatory=1)]$failureMessage
)
if (!$conditionToCheck) {
throw ("Assert: " + $failureMessage)
}
}
# .ExternalHelp psake.psm1-help.xml
function Task
{
[CmdletBinding()]
param(
[Parameter(Position=0,Mandatory=1)][string]$name = $null,
[Parameter(Position=1,Mandatory=0)][scriptblock]$action = $null,
[Parameter(Position=2,Mandatory=0)][scriptblock]$preaction = $null,
[Parameter(Position=3,Mandatory=0)][scriptblock]$postaction = $null,
[Parameter(Position=4,Mandatory=0)][scriptblock]$precondition = {$true},
[Parameter(Position=5,Mandatory=0)][scriptblock]$postcondition = {$true},
[Parameter(Position=6,Mandatory=0)][switch]$continueOnError = $false,
[Parameter(Position=7,Mandatory=0)][string[]]$depends = @(),
[Parameter(Position=8,Mandatory=0)][string[]]$requiredVariables = @(),
[Parameter(Position=9,Mandatory=0)][string]$description = $null,
[Parameter(Position=10,Mandatory=0)][string]$alias = $null,
[Parameter(Position=11,Mandatory=0)][string]$maxRetries = 0,
[Parameter(Position=12,Mandatory=0)][string]$retryTriggerErrorPattern = $null
)
if ($name -eq 'default') {
Assert (!$action) ($msgs.error_default_task_cannot_have_action)
}
$newTask = @{
Name = $name
DependsOn = $depends
PreAction = $preaction
Action = $action
PostAction = $postaction
Precondition = $precondition
Postcondition = $postcondition
ContinueOnError = $continueOnError
Description = $description
Duration = [System.TimeSpan]::Zero
RequiredVariables = $requiredVariables
Alias = $alias
MaxRetries = $maxRetries
RetryTriggerErrorPattern = $retryTriggerErrorPattern
}
$taskKey = $name.ToLower()
$currentContext = $psake.context.Peek()
Assert (!$currentContext.tasks.ContainsKey($taskKey)) ($msgs.error_duplicate_task_name -f $name)
$currentContext.tasks.$taskKey = $newTask
if($alias)
{
$aliasKey = $alias.ToLower()
Assert (!$currentContext.aliases.ContainsKey($aliasKey)) ($msgs.error_duplicate_alias_name -f $alias)
$currentContext.aliases.$aliasKey = $newTask
}
}
# .ExternalHelp psake.psm1-help.xml
function Properties {
[CmdletBinding()]
param(
[Parameter(Position=0,Mandatory=1)][scriptblock]$properties
)
$psake.context.Peek().properties += $properties
}
# .ExternalHelp psake.psm1-help.xml
function Include {
[CmdletBinding()]
param(
[Parameter(Position=0,Mandatory=1)][string]$fileNamePathToInclude
)
Assert (test-path $fileNamePathToInclude -pathType Leaf) ($msgs.error_invalid_include_path -f $fileNamePathToInclude)
$psake.context.Peek().includes.Enqueue((Resolve-Path $fileNamePathToInclude));
}
# .ExternalHelp psake.psm1-help.xml
function FormatTaskName {
[CmdletBinding()]
param(
[Parameter(Position=0,Mandatory=1)]$format
)
$psake.context.Peek().config.taskNameFormat = $format
}
# .ExternalHelp psake.psm1-help.xml
function TaskSetup {
[CmdletBinding()]
param(
[Parameter(Position=0,Mandatory=1)][scriptblock]$setup
)
$psake.context.Peek().taskSetupScriptBlock = $setup
}
# .ExternalHelp psake.psm1-help.xml
function TaskTearDown {
[CmdletBinding()]
param(
[Parameter(Position=0,Mandatory=1)][scriptblock]$teardown
)
$psake.context.Peek().taskTearDownScriptBlock = $teardown
}
# .ExternalHelp psake.psm1-help.xml
function Framework {
[CmdletBinding()]
param(
[Parameter(Position=0,Mandatory=1)][string]$framework
)
$psake.context.Peek().config.framework = $framework
ConfigureBuildEnvironment
}
# .ExternalHelp psake.psm1-help.xml
function Invoke-psake {
[CmdletBinding()]
param(
[Parameter(Position = 0, Mandatory = 0)][string] $buildFile,
[Parameter(Position = 1, Mandatory = 0)][string[]] $taskList = @(),
[Parameter(Position = 2, Mandatory = 0)][string] $framework,
[Parameter(Position = 3, Mandatory = 0)][switch] $docs = $false,
[Parameter(Position = 4, Mandatory = 0)][hashtable] $parameters = @{},
[Parameter(Position = 5, Mandatory = 0)][hashtable] $properties = @{},
[Parameter(Position = 6, Mandatory = 0)][alias("init")][scriptblock] $initialization = {},
[Parameter(Position = 7, Mandatory = 0)][switch] $nologo = $false,
[Parameter(Position = 8, Mandatory = 0)][switch] $detailedDocs = $false
)
try {
if (-not $nologo) {
"psake version {0}`nCopyright (c) 2010-2015 James Kovacs, Damian Hickey & Contributors`n" -f $psake.version
}
if (!$buildFile) {
$buildFile = $psake.config_default.buildFileName
}
elseif (!(test-path $buildFile -pathType Leaf) -and (test-path $psake.config_default.buildFileName -pathType Leaf)) {
# If the $config.buildFileName file exists and the given "buildfile" isn 't found assume that the given
# $buildFile is actually the target Tasks to execute in the $config.buildFileName script.
$taskList = $buildFile.Split(', ')
$buildFile = $psake.config_default.buildFileName
}
# Execute the build file to set up the tasks and defaults
Assert (test-path $buildFile -pathType Leaf) ($msgs.error_build_file_not_found -f $buildFile)
$psake.build_script_file = get-item $buildFile
$psake.build_script_dir = $psake.build_script_file.DirectoryName
$psake.build_success = $false
$psake.context.push(@{
"taskSetupScriptBlock" = {};
"taskTearDownScriptBlock" = {};
"executedTasks" = new-object System.Collections.Stack;
"callStack" = new-object System.Collections.Stack;
"originalEnvPath" = $env:path;
"originalDirectory" = get-location;
"originalErrorActionPreference" = $global:ErrorActionPreference;
"tasks" = @{};
"aliases" = @{};
"properties" = @();
"includes" = new-object System.Collections.Queue;
"config" = CreateConfigurationForNewContext $buildFile $framework
})
LoadConfiguration $psake.build_script_dir
$stopwatch = [System.Diagnostics.Stopwatch]::StartNew()
set-location $psake.build_script_dir
LoadModules
$frameworkOldValue = $framework
. $psake.build_script_file.FullName
$currentContext = $psake.context.Peek()
if ($framework -ne $frameworkOldValue) {
writecoloredoutput $msgs.warning_deprecated_framework_variable -foregroundcolor Yellow
$currentContext.config.framework = $framework
}
ConfigureBuildEnvironment
while ($currentContext.includes.Count -gt 0) {
$includeFilename = $currentContext.includes.Dequeue()
. $includeFilename
}
if ($docs -or $detailedDocs) {
WriteDocumentation($detailedDocs)
CleanupEnvironment
return
}
foreach ($key in $parameters.keys) {
if (test-path "variable:\$key") {
set-item -path "variable:\$key" -value $parameters.$key -WhatIf:$false -Confirm:$false | out-null
} else {
new-item -path "variable:\$key" -value $parameters.$key -WhatIf:$false -Confirm:$false | out-null
}
}
# The initial dot (.) indicates that variables initialized/modified in the propertyBlock are available in the parent scope.
foreach ($propertyBlock in $currentContext.properties) {
. $propertyBlock
}
foreach ($key in $properties.keys) {
if (test-path "variable:\$key") {
set-item -path "variable:\$key" -value $properties.$key -WhatIf:$false -Confirm:$false | out-null
}
}
# Simple dot sourcing will not work. We have to force the script block into our
# module's scope in order to initialize variables properly.
. $MyInvocation.MyCommand.Module $initialization
# Execute the list of tasks or the default task
if ($taskList) {
foreach ($task in $taskList) {
invoke-task $task
}
} elseif ($currentContext.tasks.default) {
invoke-task default
} else {
throw $msgs.error_no_default_task
}
WriteColoredOutput ("`n" + $msgs.build_success + "`n") -foregroundcolor Green
WriteTaskTimeSummary $stopwatch.Elapsed
$psake.build_success = $true
} catch {
$currentConfig = GetCurrentConfigurationOrDefault
if ($currentConfig.verboseError) {
$error_message = "{0}: An Error Occurred. See Error Details Below: `n" -f (Get-Date)
$error_message += ("-" * 70) + "`n"
$error_message += "Error: {0}`n" -f (ResolveError $_ -Short)
$error_message += ("-" * 70) + "`n"
$error_message += ResolveError $_
$error_message += ("-" * 70) + "`n"
$error_message += "Script Variables" + "`n"
$error_message += ("-" * 70) + "`n"
$error_message += get-variable -scope script | format-table | out-string
} else {
# ($_ | Out-String) gets error messages with source information included.
$error_message = "Error: {0}: `n{1}" -f (Get-Date), (ResolveError $_ -Short)
}
$psake.build_success = $false
# if we are running in a nested scope (i.e. running a psake script from a psake script) then we need to re-throw the exception
# so that the parent script will fail otherwise the parent script will report a successful build
$inNestedScope = ($psake.context.count -gt 1)
if ( $inNestedScope ) {
throw $_
} else {
if (!$psake.run_by_psake_build_tester) {
WriteColoredOutput $error_message -foregroundcolor Red
}
}
} finally {
CleanupEnvironment
}
}
#-- Private Module Functions --#
function WriteColoredOutput {
param(
[string] $message,
[System.ConsoleColor] $foregroundcolor
)
$currentConfig = GetCurrentConfigurationOrDefault
if ($currentConfig.coloredOutput -eq $true) {
if (($Host.UI -ne $null) -and ($Host.UI.RawUI -ne $null) -and ($Host.UI.RawUI.ForegroundColor -ne $null)) {
$previousColor = $Host.UI.RawUI.ForegroundColor
$Host.UI.RawUI.ForegroundColor = $foregroundcolor
}
}
$message
if ($previousColor -ne $null) {
$Host.UI.RawUI.ForegroundColor = $previousColor
}
}
function LoadModules {
$currentConfig = $psake.context.peek().config
if ($currentConfig.modules) {
$scope = $currentConfig.moduleScope
$global = [string]::Equals($scope, "global", [StringComparison]::CurrentCultureIgnoreCase)
$currentConfig.modules | foreach {
resolve-path $_ | foreach {
"Loading module: $_"
$module = import-module $_ -passthru -DisableNameChecking -global:$global
if (!$module) {
throw ($msgs.error_loading_module -f $_.Name)
}
}
}
""
}
}
function LoadConfiguration {
param(
[string] $configdir = $PSScriptRoot
)
$psakeConfigFilePath = (join-path $configdir "psake-config.ps1")
if (test-path $psakeConfigFilePath -pathType Leaf) {
try {
$config = GetCurrentConfigurationOrDefault
. $psakeConfigFilePath
} catch {
throw "Error Loading Configuration from psake-config.ps1: " + $_
}
}
}
function GetCurrentConfigurationOrDefault() {
if ($psake.context.count -gt 0) {
return $psake.context.peek().config
} else {
return $psake.config_default
}
}
function CreateConfigurationForNewContext {
param(
[string] $buildFile,
[string] $framework
)
$previousConfig = GetCurrentConfigurationOrDefault
$config = new-object psobject -property @{
buildFileName = $previousConfig.buildFileName;
framework = $previousConfig.framework;
taskNameFormat = $previousConfig.taskNameFormat;
verboseError = $previousConfig.verboseError;
coloredOutput = $previousConfig.coloredOutput;
modules = $previousConfig.modules;
moduleScope = $previousConfig.moduleScope;
}
if ($framework) {
$config.framework = $framework;
}
if ($buildFile) {
$config.buildFileName = $buildFile;
}
return $config
}
function ConfigureBuildEnvironment {
$framework = $psake.context.peek().config.framework
if ($framework -cmatch '^((?:\d+\.\d+)(?:\.\d+){0,1})(x86|x64){0,1}$') {
$versionPart = $matches[1]
$bitnessPart = $matches[2]
} else {
throw ($msgs.error_invalid_framework -f $framework)
}
$versions = $null
$buildToolsVersions = $null
switch ($versionPart) {
'1.0' {
$versions = @('v1.0.3705')
}
'1.1' {
$versions = @('v1.1.4322')
}
'2.0' {
$versions = @('v2.0.50727')
}
'3.0' {
$versions = @('v2.0.50727')
}
'3.5' {
$versions = @('v3.5', 'v2.0.50727')
}
'4.0' {
$versions = @('v4.0.30319')
}
{($_ -eq '4.5.1') -or ($_ -eq '4.5.2')} {
$versions = @('v4.0.30319')
$buildToolsVersions = @('14.0', '12.0')
}
'4.6' {
$versions = @('v4.0.30319')
$buildToolsVersions = @('14.0')
}
default {
throw ($msgs.error_unknown_framework -f $versionPart, $framework)
}
}
$bitness = 'Framework'
if ($versionPart -ne '1.0' -and $versionPart -ne '1.1') {
switch ($bitnessPart) {
'x86' {
$bitness = 'Framework'
$buildToolsKey = 'MSBuildToolsPath32'
}
'x64' {
$bitness = 'Framework64'
$buildToolsKey = 'MSBuildToolsPath'
}
{ [string]::IsNullOrEmpty($_) } {
$ptrSize = [System.IntPtr]::Size
switch ($ptrSize) {
4 {
$bitness = 'Framework'
$buildToolsKey = 'MSBuildToolsPath32'
}
8 {
$bitness = 'Framework64'
$buildToolsKey = 'MSBuildToolsPath'
}
default {
throw ($msgs.error_unknown_pointersize -f $ptrSize)
}
}
}
default {
throw ($msgs.error_unknown_bitnesspart -f $bitnessPart, $framework)
}
}
}
$frameworkDirs = @()
if ($buildToolsVersions -ne $null) {
foreach($ver in $buildToolsVersions) {
if (Test-Path "HKLM:\SOFTWARE\Microsoft\MSBuild\ToolsVersions\$ver") {
$frameworkDirs += (Get-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\MSBuild\ToolsVersions\$ver" -Name $buildToolsKey).$buildToolsKey
}
}
}
$frameworkDirs = $frameworkDirs + @($versions | foreach { "$env:windir\Microsoft.NET\$bitness\$_\" })
for ($i = 0; $i -lt $frameworkDirs.Count; $i++) {
$dir = $frameworkDirs[$i]
if ($dir -Match "\$\(Registry:HKEY_LOCAL_MACHINE(.*?)@(.*)\)") {
$key = "HKLM:" + $matches[1]
$name = $matches[2]
$dir = (Get-ItemProperty -Path $key -Name $name).$name
$frameworkDirs[$i] = $dir
}
}
$frameworkDirs | foreach { Assert (test-path $_ -pathType Container) ($msgs.error_no_framework_install_dir_found -f $_)}
$env:path = ($frameworkDirs -join ";") + ";$env:path"
# if any error occurs in a PS function then "stop" processing immediately
# this does not effect any external programs that return a non-zero exit code
$global:ErrorActionPreference = "Stop"
}
function CleanupEnvironment {
if ($psake.context.Count -gt 0) {
$currentContext = $psake.context.Peek()
$env:path = $currentContext.originalEnvPath
Set-Location $currentContext.originalDirectory
$global:ErrorActionPreference = $currentContext.originalErrorActionPreference
[void] $psake.context.Pop()
}
}
function SelectObjectWithDefault
{
[CmdletBinding()]
param(
[Parameter(ValueFromPipeline=$true)]
[PSObject]
$InputObject,
[string]
$Name,
$Value
)
process {
if ($_ -eq $null) { $Value }
elseif ($_ | Get-Member -Name $Name) {
$_.$Name
}
elseif (($_ -is [Hashtable]) -and ($_.Keys -contains $Name)) {
$_.$Name
}
else { $Value }
}
}
# borrowed from Jeffrey Snover http://blogs.msdn.com/powershell/archive/2006/12/07/resolve-error.aspx
# modified to better handle SQL errors
function ResolveError
{
[CmdletBinding()]
param(
[Parameter(ValueFromPipeline=$true)]
$ErrorRecord=$Error[0],
[Switch]
$Short
)
process {
if ($_ -eq $null) { $_ = $ErrorRecord }
$ex = $_.Exception
if (-not $Short) {
$error_message = "`nErrorRecord:{0}ErrorRecord.InvocationInfo:{1}Exception:`n{2}"
$formatted_errorRecord = $_ | format-list * -force | out-string
$formatted_invocationInfo = $_.InvocationInfo | format-list * -force | out-string
$formatted_exception = ''
$i = 0
while ($ex -ne $null) {
$i++
$formatted_exception += ("$i" * 70) + "`n" +
($ex | format-list * -force | out-string) + "`n"
$ex = $ex | SelectObjectWithDefault -Name 'InnerException' -Value $null
}
return $error_message -f $formatted_errorRecord, $formatted_invocationInfo, $formatted_exception
}
$lastException = @()
while ($ex -ne $null) {
$lastMessage = $ex | SelectObjectWithDefault -Name 'Message' -Value ''
$lastException += ($lastMessage -replace "`n", '')
if ($ex -is [Data.SqlClient.SqlException]) {
$lastException += "(Line [$($ex.LineNumber)] " +
"Procedure [$($ex.Procedure)] Class [$($ex.Class)] " +
" Number [$($ex.Number)] State [$($ex.State)] )"
}
$ex = $ex | SelectObjectWithDefault -Name 'InnerException' -Value $null
}
$shortException = $lastException -join ' --> '
$header = $null
$current = $_
$header = (($_.InvocationInfo |
SelectObjectWithDefault -Name 'PositionMessage' -Value '') -replace "`n", ' '),
($_ | SelectObjectWithDefault -Name 'Message' -Value ''),
($_ | SelectObjectWithDefault -Name 'Exception' -Value '') |
? { -not [String]::IsNullOrEmpty($_) } |
Select -First 1
$delimiter = ''
if ((-not [String]::IsNullOrEmpty($header)) -and
(-not [String]::IsNullOrEmpty($shortException)))
{ $delimiter = ' [<<==>>] ' }
return "$($header)$($delimiter)Exception: $($shortException)"
}
}
function WriteDocumentation($showDetailed) {
$currentContext = $psake.context.Peek()
if ($currentContext.tasks.default) {
$defaultTaskDependencies = $currentContext.tasks.default.DependsOn
} else {
$defaultTaskDependencies = @()
}
$docs = $currentContext.tasks.Keys | foreach-object {
if ($_ -eq "default") {
return
}
$task = $currentContext.tasks.$_
new-object PSObject -property @{
Name = $task.Name;
Alias = $task.Alias;
Description = $task.Description;
"Depends On" = $task.DependsOn -join ", "
Default = if ($defaultTaskDependencies -contains $task.Name) { $true }
}
}
if ($showDetailed) {
$docs | sort 'Name' | format-list -property Name,Alias,Description,"Depends On",Default
} else {
$docs | sort 'Name' | format-table -autoSize -wrap -property Name,Alias,"Depends On",Default,Description
}
}
function WriteTaskTimeSummary($invokePsakeDuration) {
if ($psake.context.count -gt 0) {
"-" * 70
"Build Time Report"
"-" * 70
$list = @()
$currentContext = $psake.context.Peek()
while ($currentContext.executedTasks.Count -gt 0) {
$taskKey = $currentContext.executedTasks.Pop()
$task = $currentContext.tasks.$taskKey
if ($taskKey -eq "default") {
continue
}
$list += new-object PSObject -property @{
Name = $task.Name;
Duration = $task.Duration
}
}
[Array]::Reverse($list)
$list += new-object PSObject -property @{
Name = "Total:";
Duration = $invokePsakeDuration
}
# using "out-string | where-object" to filter out the blank line that format-table prepends
$list | format-table -autoSize -property Name,Duration | out-string -stream | where-object { $_ }
}
}
DATA msgs {
convertfrom-stringdata @'
error_invalid_task_name = Task name should not be null or empty string.
error_task_name_does_not_exist = Task {0} does not exist.
error_circular_reference = Circular reference found for task {0}.
error_missing_action_parameter = Action parameter must be specified when using PreAction or PostAction parameters for task {0}.
error_corrupt_callstack = Call stack was corrupt. Expected {0}, but got {1}.
error_invalid_framework = Invalid .NET Framework version, {0} specified.
error_unknown_framework = Unknown .NET Framework version, {0} specified in {1}.
error_unknown_pointersize = Unknown pointer size ({0}) returned from System.IntPtr.
error_unknown_bitnesspart = Unknown .NET Framework bitness, {0}, specified in {1}.
error_no_framework_install_dir_found = No .NET Framework installation directory found at {0}.
error_bad_command = Error executing command {0}.
error_default_task_cannot_have_action = 'default' task cannot specify an action.
error_duplicate_task_name = Task {0} has already been defined.
error_duplicate_alias_name = Alias {0} has already been defined.
error_invalid_include_path = Unable to include {0}. File not found.
error_build_file_not_found = Could not find the build file {0}.
error_no_default_task = 'default' task required.
error_loading_module = Error loading module {0}.
warning_deprecated_framework_variable = Warning: Using global variable $framework to set .NET framework version used is deprecated. Instead use Framework function or configuration file psake-config.ps1.
required_variable_not_set = Variable {0} must be set to run task {1}.
postcondition_failed = Postcondition failed for task {0}.
precondition_was_false = Precondition was false, not executing task {0}.
continue_on_error = Error in task {0}. {1}
build_success = Build Succeeded!
'@
}
import-localizeddata -bindingvariable msgs -erroraction silentlycontinue
$script:psake = @{}
$psake.version = "4.4.2" # contains the current version of psake
$psake.context = new-object system.collections.stack # holds onto the current state of all variables
$psake.run_by_psake_build_tester = $false # indicates that build is being run by psake-BuildTester
$psake.config_default = new-object psobject -property @{
buildFileName = "default.ps1";
framework = "4.0";
taskNameFormat = "Executing {0}";
verboseError = $false;
coloredOutput = $true;
modules = $null;
moduleScope = "";
} # contains default configuration, can be overriden in psake-config.ps1 in directory with psake.psm1 or in directory with current build script
$psake.build_success = $false # indicates that the current build was successful
$psake.build_script_file = $null # contains a System.IO.FileInfo for the current build script
$psake.build_script_dir = "" # contains a string with fully-qualified path to current build script
LoadConfiguration
export-modulemember -function Invoke-psake, Invoke-Task, Task, Properties, Include, FormatTaskName, TaskSetup, TaskTearDown, Framework, Assert, Exec -variable psake
================================================
FILE: Build/runbuild.cmd
================================================
cls
powershell -Command "& { Start-Transcript '%~dp0\Temp\runbuild.txt'; Import-Module '%~dp0\psake.psm1'; Invoke-psake '%~dp0..\Build\build.ps1' %*; Stop-Transcript; exit !($psake.build_success); }"
ECHO %ERRORLEVEL%
EXIT /B %ERRORLEVEL%
================================================
FILE: Build/runbuild.ps1
================================================
param(
[hashtable] $parameters = @{},
[hashtable] $properties = @{}
)
$path = Split-Path -Path $MyInvocation.MyCommand.Path
write-host "Importing psake"
Import-Module ($path + '\psake.psm1')
Try
{
write-host "Starting build.ps1"
Invoke-psake ($path + '\build.ps1') -properties $properties -parameters $parameters
if ($psake.build_success -eq $false)
{
write-host "build.ps1 failed" -fore RED
exit 1
}
else
{
write-host "build.ps1 succeeded" -fore GREEN
exit 0
}
}
Finally
{
Remove-Module psake
}
================================================
FILE: Build/version.json
================================================
{
"Major": 13,
"Release": 5,
"Prerelease": "beta1",
"Assembly": null
}
================================================
FILE: CONTRIBUTING.md
================================================
# How to contribute
Please read these guidelines before contributing to Json.NET:
- [Question or Problem?](#question)
- [Issues and Bugs](#issue)
- [Feature Requests](#feature)
- [Submitting a Pull Request](#pullrequest)
- [Contributor License Agreement](#cla)
## Got a Question or Problem?
If you have questions about how to use Json.NET, please read the
[Json.NET documentation][documentation] or ask on [Stack Overflow][stackoverflow]. There are
thousands of Json.NET questions on Stack Overflow with the [json.net][stackoverflow] tag.
GitHub issues are only for [reporting bugs](#issue) and [feature requests](#feature), not
questions or help.
## Found an Issue?
If you find a bug in the source code or a mistake in the documentation, you can help by
submitting an issue to the [GitHub Repository][github]. Even better you can submit a Pull Request
with a fix.
When submitting an issue please include the following information:
- A description of the issue
- The JSON, classes, and Json.NET code related to the issue
- The exception message and stacktrace if an error was thrown
- If possible, please include code that reproduces the issue. [DropBox][dropbox] or GitHub's
[Gist][gist] can be used to share large code samples, or you could
[submit a pull request](#pullrequest) with the issue reproduced in a new test.
The more information you include about the issue, the more likely it is to be fixed!
## Want a Feature?
You can request a new feature by submitting an issue to the [GitHub Repository][github]. Before
requesting a feature consider the following:
- Json.NET has many extensibility points, it is possible you can implement your feature today without
modifying Json.NET
- Stability is important. Json.NET is used by thousands of other libraries and features that require
large breaking changes are unlikely to be accepted
## Submitting a Pull Request
When submitting a pull request to the [GitHub Repository][github] make sure to do the following:
- Check that new and updated code follows Json.NET's existing code formatting and naming standard
- Run Json.NET's unit tests to ensure no existing functionality has been affected
- Write new unit tests to test your changes. All features and fixed bugs must have tests to verify
they work
Read [GitHub Help][pullrequesthelp] for more details about creating pull requests.
## Contributor License Agreement
By contributing your code to Json.NET you grant James Newton-King a non-exclusive, irrevocable, worldwide,
royalty-free, sublicenseable, transferable license under all of Your relevant intellectual property rights
(including copyright, patent, and any other rights), to use, copy, prepare derivative works of, distribute and
publicly perform and display the Contributions on any licensing terms, including without limitation:
(a) open source licenses like the MIT license; and (b) binary, proprietary, or commercial licenses. Except for the
licenses granted herein, You reserve all right, title, and interest in and to the Contribution.
You confirm that you are able to grant us these rights. You represent that You are legally entitled to grant the
above license. If Your employer has rights to intellectual property that You create, You represent that You have
received permission to make the Contributions on behalf of that employer, or that Your employer has waived such
rights for the Contributions.
You represent that the Contributions are Your original works of authorship, and to Your knowledge, no other person
claims, or has the right to claim, any right in any invention or patent related to the Contributions. You also
represent that You are not legally obligated, whether by entering into an agreement or otherwise, in any way that
conflicts with the terms of this license.
James Newton-King acknowledges that, except as explicitly described in this Agreement, any Contribution which
you provide is on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED,
INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS
FOR A PARTICULAR PURPOSE.
[github]: https://github.com/JamesNK/Newtonsoft.Json
[documentation]: https://www.newtonsoft.com/json/help
[stackoverflow]: https://stackoverflow.com/questions/tagged/json.net
[dropbox]: https://www.dropbox.com
[gist]: https://gist.github.com
[pullrequesthelp]: https://help.github.com/articles/using-pull-requests
================================================
FILE: Doc/ConditionalProperties.aml
================================================
Json.NET has the ability to conditionally serialize properties by placing a ShouldSerialize method on a class.
This functionality is similar to the XmlSerializer ShouldSerialize featurehttp://msdn.microsoft.com/en-us/library/53b8022e.aspx_blank.ShouldSerializeTo conditionally serialize a property, add a method that returns boolean with the same name as the property and then prefix the method name
with ShouldSerialize. The result of the method determines whether the property is serialized. If the method returns true then the
property will be serialized, if it returns false then the property will be skipped.IContractResolverShouldSerialize can also be set using an T:Newtonsoft.Json.Serialization.IContractResolver.
Conditionally serializing a property using an IContractResolver is useful if you don't want to place a ShouldSerialize method on a class
or you didn't declare the class and are unable to.T:Newtonsoft.Json.JsonSerializerT:Newtonsoft.Json.Serialization.IContractResolverP:Newtonsoft.Json.Serialization.JsonProperty.ShouldSerialize
================================================
FILE: Doc/ContractResolver.aml
================================================
The T:Newtonsoft.Json.Serialization.IContractResolver
interface provides a way to customize how the
JsonSerializer serializes and deserializes .NET objects to JSON without placing attributes on your classes.
Anything that can be set on an object, collection, property, etc, using attributes or methods to control serialization
can also be set using an IContractResolver.For performance you should create a contract resolver once and reuse instances when possible. Resolving contracts is slow and implementations of T:Newtonsoft.Json.Serialization.IContractResolver typically cache contracts.DefaultContractResolverThe T:Newtonsoft.Json.Serialization.DefaultContractResolver
is the default resolver used by the
serializer. It provides many avenues of extensibility in the form of
virtual methods that can be overridden.CamelCasePropertyNamesContractResolverT:Newtonsoft.Json.Serialization.CamelCasePropertyNamesContractResolver
inherits from DefaultContractResolver and simply overrides the JSON
property name to be written in camelcasehttp://en.wikipedia.org/wiki/CamelCase_blank.Custom IContractResolver ExamplesThis example sets a T:Newtonsoft.Json.JsonConverter for a type
using an IContractResolver. Using a contract resolver here is useful because DateTime is not your own type and it is not possible to place a JsonConverterAttribute on it.This example sets up conditional serialization for a property using an IContractResolver. This is useful if you want to conditionally serialize a property but don't want to add additional methods to your type.T:Newtonsoft.Json.Serialization.IContractResolverT:Newtonsoft.Json.Serialization.DefaultContractResolverT:Newtonsoft.Json.Serialization.CamelCasePropertyNamesContractResolver
================================================
FILE: Doc/ConvertingJSONandXML.aml
================================================
Json.NET supports converting JSON to XML and vice versa using the
T:Newtonsoft.Json.Converters.XmlNodeConverter.Elements, attributes, text, comments, character data, processing instructions,
namespaces, and the XML declaration are all preserved when converting between the two. The
only caveat is that it is possible to lose the order of differently named nodes at the
same level when they are grouped together into an array.Conversion RulesElements remain unchanged.Attributes are prefixed with an @ and should be at the start of the object.Single child text nodes are a value directly against an element, otherwise they are accessed via #text.The XML declaration and processing instructions are prefixed with ?.Character data, comments, whitespace and significant whitespace nodes are accessed via
#cdata-section, #comment, #whitespace and #significant-whitespace respectively.Multiple nodes with the same name at the same level are grouped together into an array.Empty elements are null.If the XML created from JSON doesn't match what you want, then you will need to convert it manually.
The best approach to do this is to load your JSON into a LINQ to JSON object like JObject or JArray and then use LINQ to create
an XDocument. The opposite process, using LINQ with an XDocument to create a JObject or JArray, also works.
You can find out more about using LINQ to JSON with LINQ here.The version of Json.NET being used in your application will change what XML conversion methods are available.
SerializeXmlNode/DeserializeXmlNode are available when the framework supports XmlDocument;
SerializeXNode/DeserializeXNode are available when the framework supports XDocument.SerializeXmlNodeThe JsonConvert has two helper methods for converting between JSON and XML. The first is
Overload:Newtonsoft.Json.JsonConvert.SerializeXmlNode.
This method takes an XmlNode and serializes it to JSON text.Because multiple nodes with the same name at the same level are grouped together into an array,
the conversion process can produce different JSON depending on the number of nodes. For example, if some
XML for a user has a single <Role> node, then that role will be text against
a JSON "Role" property, but if the user has multiple <Role>
nodes, then the role values will be placed in a JSON array.To fix this situation a custom XML attribute can be added to force a JSON array to be created.DeserializeXmlNodeThe second helper method on JsonConvert is
Overload:Newtonsoft.Json.JsonConvert.DeserializeXmlNode.
This method takes JSON text and deserializes it into an XmlNode.Because valid XML must have one root element, the JSON passed to DeserializeXmlNode should
have one property in the root JSON object. If the root JSON object has multiple properties, then
the overload that also takes an element name should be used. A root element with that name will
be inserted into the deserialized XmlNode.T:Newtonsoft.Json.Converters.XmlNodeConverterT:Newtonsoft.Json.JsonConvert
================================================
FILE: Doc/CreatingLINQtoJSON.aml
================================================
As well as parsing JSON from existing JSON strings, LINQ to JSON objects can be created from scratch to create new JSON structures.Manually Creating JSONSetting values and creating objects and arrays one at a time gives you
total control, but it is more verbose than other options.Creating JSON with LINQDeclaratively creating JSON objects using LINQ is a fast way to create JSON from collections of values.Creating JSON from an objectThe last option is to create a JSON object from a non-JSON type using the
Overload:Newtonsoft.Json.Linq.JObject.FromObject
method. Internally, FromObject will use the JsonSerializer to serialize the object to LINQ to JSON objects instead of text.The example below shows creating a JSON object from an anonymous object, but any
.NET type can be used with FromObject to create JSON.Overload:Newtonsoft.Json.Linq.JObject.FromObject
================================================
FILE: Doc/CustomCreationConverter.aml
================================================
The T:Newtonsoft.Json.Converters.CustomCreationConverter`1
is a JsonConverter that provides a way
to customize how an object is created during JSON deserialization. Once
the object has been created it will then have values populated onto it by
the serializer.ExampleThis is an extremely simple example. A more complicated scenario
could involve an object factory or service locator that resolves the
object at runtime.T:Newtonsoft.Json.Converters.CustomCreationConverter`1
================================================
FILE: Doc/DatesInJSON.aml
================================================
DateTimes in JSON are hard.The problem comes from the JSON spechttp://www.ietf.org/rfc/rfc4627.txt_blank itself: there is no literal
syntax for dates in JSON. The spec has objects, arrays, strings, integers,
and floats, but it defines no standard for what a date looks like.Dates and Json.NETThe default format used by Json.NET is the ISO 8601 standardhttp://en.wikipedia.org/wiki/ISO_8601_blank: "2012-03-19T07:22Z".Prior to Json.NET 4.5 dates were written using the Microsoft
format: "\/Date(1198908717056)\/". If you want to use this format, or
you want to maintain compatibility with Microsoft JSON serializers or
older versions of Json.NET, then change the
T:Newtonsoft.Json.DateFormatHandling
setting to MicrosoftDateFormat.The T:Newtonsoft.Json.DateTimeZoneHandling setting can be
used to convert a DateTime's T:System.DateTimeKind when serializing. For example set
DateTimeZoneHandling to Utc to serialize all DateTimes as UTC dates. Note that this setting does not effect DateTimeOffsets.If your dates don't follow the ISO 8601 standard, then the DateFormatString setting can be used to customize the format of
date strings that are read and written using .NET's custom date and time format syntaxhttps://msdn.microsoft.com/en-us/library/8kb3ddd4.aspx_blank.DateTime JsonConvertersWith no standard for dates in JSON, the number of possible
different formats when interoping with other systems is endless.
Fortunately Json.NET has a solution to deal with reading and writing
custom dates: JsonConverters. A JsonConverter is used to override how a
type is serialized.Simply pass the JsonConverter you wish to use to the Json.NET
serializer.JavaScriptDateTimeConverterThe JavaScriptDateTimeConverter class is one of the two DateTime
JsonConverters that come with Json.NET. This converter serializes a
DateTime as a JavaScript Date objecthttp://msdn.microsoft.com/en-us/library/cd9w2te4.aspx_blank: new Date(1234656000000)Technically this is invalid JSON according to the spec, but all
browsers and some JSON frameworks, including Json.NET, support it.IsoDateTimeConverterFrom Json.NET 4.5 and onwards dates are written using the ISO 8601
format by default, and using this converter is unnecessary.IsoDateTimeConverter serializes a DateTime to an ISO 8601http://en.wikipedia.org/wiki/ISO_8601_blank formatted
string: "2009-02-15T00:00:00Z"The IsoDateTimeConverter class has a property, DateTimeFormat, to
further customize the formatted string.T:Newtonsoft.Json.DateFormatHandlingT:Newtonsoft.Json.DateTimeZoneHandlingT:Newtonsoft.Json.Converters.JavaScriptDateTimeConverterT:Newtonsoft.Json.Converters.IsoDateTimeConverter
================================================
FILE: Doc/Introduction.aml
================================================
Json.NET is a popular high-performance JSON framework for .NETBenefits and FeaturesFlexible JSON serializer for converting between .NET objects and JSONLINQ to JSON for manually reading and writing JSON High performance: faster than .NET's built-in JSON serializersWrite indented, easy-to-read JSONConvert JSON to and from XMLSupports .NET Standard 2.0https://github.com/dotnet/standard/blob/master/docs/versions.md_blank,
.NET 2, .NET 3.5, .NET 4, .NET 4.5, Silverlight, Windows Phone and Windows 8 StoreThe JSON serializer in Json.NET is a good choice when the JSON you are reading or writing maps closely to a .NET class.LINQ to JSON is good for situations where you are only interested in
getting values from JSON, you don't have a class to serialize or deserialize to,
or the JSON is radically different from your class and you need to manually read
and write from your objects.Getting StartedHistoryJson.NET grew out of projects I was working on in late 2005 involving JavaScript,
AJAX, and .NET. At the time there were no libraries for working with JavaScript in
.NET, so I made my own.Starting out as a couple of static methods for escaping JavaScript strings, Json.NET
evolved as features were added. To add support for reading JSON a major refactor
was required, and Json.NET was split into the three major classes it still uses
today: JsonReader, JsonWriter and JsonSerializer.Json.NET was first released in June 2006. Since then Json.NET has been downloaded
hundreds of thousands of times by developers from around the world. It is used in many major open
source projects, including: Monohttp://www.mono-project.com/_blank,
an open source implementation
of the .NET framework; RavenDBhttp://ravendb.net/_blank,
a JSON based document database; ASP.NET SignalRhttp://signalr.net/_blank,
an async library for building real-time, multi-user interactive web applications; and ASP.NET Corehttp://www.asp.net_blank,
Microsoft's web app and service framework.
================================================
FILE: Doc/JsonNetVsDotNetSerializers.aml
================================================
Json.NET offers many features not found in the JavaScriptSerializer and DataContractSerializer that come with .NET.Feature Comparison
Json.NETDataContractJsonSerializerJavaScriptSerializerSupports JSONSupports BSONSupports JSONPathSupports .NET 2.0Supports .NET 3.5Supports .NET 4.0Supports .NET 4.5Supports SilverlightSupports Windows PhoneSupports Windows StoreSupports XamarinOpen SourceMIT LicenseLINQ to JSONThread SafeXPath-like JSON query syntaxIndented JSON supportEfficient dictionary serializationhttp://stackoverflow.com/questions/1207731/how-can-i-deserialize-json-to-a-simple-dictionarystring-string-in-asp-net_blankNonsensical dictionary serializationhttp://stackoverflow.com/questions/4559991/any-way-to-make-datacontractjsonserializer-serialize-dictionaries-properly_blankDeserializes IList, IEnumerable, ICollection, IDictionary propertiesSerializes circular referencesSupports serializing objects by referenceDeserializes polymorphic properties and collectionsSerializes and deserializes multidimensional arraysSupports including type names with JSONGlobally customize serialization processSupports excluding null values when serializingSupports SerializationBinderConditional property serializationIncludes line number information in errorsConverts XML to JSON and JSON to XMLJSON Schema validationJSON Schema generation from .NET typesCamel case JSON property namesNon-default constructors supportSerialization error handlingSupports populating an existing objectEfficiently serializes byte arrays as base64 textHandles NaN, Infinity, -Infinity and undefinedHandles JavaScript constructorsSerializes .NET 4.0 dynamic objectsSerializes ISerializable objectsSupports serializing enums to their text nameJSON recursion limit supportAttribute property name customizationAttribute property order customizationAttribute property required customizationSupports ISO8601 datesSupports JavaScript constructor datesSupports Microsoft AJAX datesUnquoted property names supportRaw JSON supportSupports reading and writing commentsSerializes anonymous typesDeserializes anonymous typesOpt-in mode serializationOpt-out mode serializationField (Serializable) mode serializationEfficiently stream reading and writing JSONSingle or double quote JSON contentSupports overriding a type's serializationSupports OnDeserialized, OnSerializing, OnSerialized and OnDeserializing attributesSupports serializing private propertiesDataMember attribute supportMetdataType attribute supportDefaultValue attribute supportSerializes DataSets and DataTablesSerializes Entity FrameworkSerializes nHibernateCase-insensitive property deserializationDiagnostic tracingSerializes read-only and immutable collectionsSupports serialization extension dataSerializes F# discriminated unionsSerializes F# collectionsSupports merging JSON
BenchmarksJson.NET Performance
================================================
FILE: Doc/JsonSchema.aml
================================================
Json.NET supports the JSON Schema standard via the T:Newtonsoft.Json.Schema.JsonSchema
and T:Newtonsoft.Json.JsonValidatingReader classes. It sits under
the N:Newtonsoft.Json.Schema namespace.JSON Schema is used to validate the structure and
data types of a piece of JSON, similar to XML Schema for XML. You can read more about JSON Schema at
json-schema.orghttp://json-schema.org/_blankObsolete. JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschemahttps://www.newtonsoft.com/jsonschema_blank
for more details.
Validating with JSON SchemaThe simplest way to check if JSON is valid is to load the JSON into a JObject or JArray and then
use the M:Newtonsoft.Json.Schema.Extensions.IsValid(Newtonsoft.Json.Linq.JToken,Newtonsoft.Json.Schema.JsonSchema)
method with the JSON Schema.To get validation error messages, use the
M:Newtonsoft.Json.Schema.Extensions.IsValid(Newtonsoft.Json.Linq.JToken,Newtonsoft.Json.Schema.JsonSchema,System.Collections.Generic.IList{System.String}@)
or
M:Newtonsoft.Json.Schema.Extensions.Validate(Newtonsoft.Json.Linq.JToken,Newtonsoft.Json.Schema.JsonSchema,Newtonsoft.Json.Schema.ValidationEventHandler)
overloads.Internally IsValid uses T:Newtonsoft.Json.JsonValidatingReader
to perform the JSON Schema validation. To skip the overhead of loading JSON into a JObject/JArray, validating
the JSON, and then deserializing the JSON into a class, JsonValidatingReader can be used with JsonSerializer to validate JSON while the object is being deserialized.Creating JSON SchemasThe simplest way to get a T:Newtonsoft.Json.Schema.JsonSchema object is to load it from a string or a file.It is also possible to create JsonSchema objects in code.T:Newtonsoft.Json.Schema.JsonSchemaT:Newtonsoft.Json.JsonValidatingReader
================================================
FILE: Doc/LINQtoJSON.aml
================================================
LINQ to JSON is an API for working with JSON objects.
It has been designed with LINQ in mind to enable quick querying
and creation of JSON objects. LINQ to JSON sits under the
N:Newtonsoft.Json.Linq
namespace.TopicsSelect a topic below for more information:T:Newtonsoft.Json.Linq.JObjectT:Newtonsoft.Json.Linq.JArrayT:Newtonsoft.Json.Linq.JValue
================================================
FILE: Doc/ParsingLINQtoJSON.aml
================================================
LINQ to JSON has methods available for parsing JSON from a string or loading JSON directly from a file.Parsing JSON textJSON values can be read from a string using
M:Newtonsoft.Json.Linq.JToken.Parse(System.String).Loading JSON from a fileJSON can also be loaded directly from a file using M:Newtonsoft.Json.Linq.JToken.ReadFrom(Newtonsoft.Json.JsonReader).M:Newtonsoft.Json.Linq.JToken.Parse(System.String)M:Newtonsoft.Json.Linq.JToken.ReadFrom(Newtonsoft.Json.JsonReader)
================================================
FILE: Doc/Performance.aml
================================================
Out of the box Json.NET is faster than DataContractJsonSerializer and JavaScriptSerializer.
Here are some tips to make it go even faster.Reuse Contract ResolverThe T:Newtonsoft.Json.Serialization.IContractResolver resolves .NET types to contracts that are used during serialization inside JsonSerializer.
Creating a contract involves inspecting a type with slow reflection, so contracts are typically
cached by implementations of IContractResolver like T:Newtonsoft.Json.Serialization.DefaultContractResolver.To avoid the overhead of recreating contracts every time you use JsonSerializer you should create the contract resolver once and reuse it.
Note that if you are not using a contract resolver then a shared internal instance is automatically used when serializing and deserializing.
Optimize Memory UsageTo keep an application consistently fast, it is important to minimize the
amount of time the .NET framework spends performing garbage collectionhttp://msdn.microsoft.com/en-us/library/ms973837.aspx_blank.
Allocating too many objects or allocating very large objects can slow down or even
halt an application while garbage collection is in progress.
To minimize memory usage and the number of objects allocated, Json.NET supports
serializing and deserializing directly to a stream. Reading or writing JSON a piece at a time, instead of having
the entire JSON string loaded into memory, is especially important when working with JSON
documents greater than 85kb in size to avoid the JSON string ending up in the large object heaphttp://msdn.microsoft.com/en-us/magazine/cc534993.aspx_blank.JsonConvertersPassing a T:Newtonsoft.Json.JsonConverter to SerializeObject or DeserializeObject provides a simple way to completely
change how an object is serialized. There is, however, a small amount of overhead; the CanConvert method is called for every
value to check whether serialization should be handled by that JsonConverter.There are a couple of ways to continue to use JsonConverters without any overhead. The simplest way
is to specify the JsonConverter using the T:Newtonsoft.Json.JsonConverterAttribute. This attribute tells the serializer
to always use that converter when serializing and deserializing the type, without the check.If the class you want to convert isn't your own and you're unable to use an attribute, a JsonConverter can still be used by
creating your own T:Newtonsoft.Json.Serialization.IContractResolver.The IContractResolver in the example above will set all DateTimes to use the JavaScriptDateConverter.Manually SerializeThe absolute fastest way to read and write JSON is to use JsonTextReader/JsonTextWriter directly to manually serialize types.
Using a reader or writer directly skips any of the overhead from a serializer, such as reflection.
If performance is important and you don't mind writing more code to get it, then this is your best choice. You can read more about using JsonReader/JsonWriter here:
BenchmarksJson.NET PerformanceT:Newtonsoft.Json.JsonSerializerT:Newtonsoft.Json.JsonConverterT:Newtonsoft.Json.JsonConverterAttributeT:Newtonsoft.Json.JsonTextWriterT:Newtonsoft.Json.JsonTextReader
================================================
FILE: Doc/PreserveObjectReferences.aml
================================================
By default Json.NET will serialize all objects it encounters by value.
If a list contains two Person references and both references point to the
same object, then the JsonSerializer will write out all the names and values
for each reference.In most cases this is the desired result, but in certain scenarios
writing the second item in the list as a reference to the first is a better
solution. If the above JSON was deserialized now, then the returned list would
contain two completely separate Person objects with the same values. Writing
references by value will also cause problems on objects where a circular
reference occurs.PreserveReferencesHandlingSetting T:Newtonsoft.Json.PreserveReferencesHandling will track object references
when serializing and deserializing JSON.The first Person in the list is serialized with the addition of an
object ID. The second Person in JSON is now only a reference to the first.With PreserveReferencesHandling on, now only one Person object is created
on deserialization and the list contains two references to it, mirroring
what we started with.
Metadata properties like $id must be located at the beginning of a JSON object to be successfully detected during deserialization. If you can't control
the order of properties in your JSON object then T:Newtonsoft.Json.MetadataPropertyHandling can be used to remove this restriction.
References cannot be preserved when a value is set via a non-default constructor.
With a non-default constructor, child values must be created before the parent value so they can be passed into
the constructor, making tracking reference impossible.
T:System.Runtime.Serialization.ISerializable types are an example
of a class whose values are populated with a non-default constructor and won't work with PreserveReferencesHandling.IsReferenceThe PreserveReferencesHandling setting on the JsonSerializer will
change how all objects are serialized and deserialized. For fine grain
control over which objects and members should be serialized as a
reference there is the IsReference property on the JsonObjectAttribute,
JsonArrayAttribute and JsonPropertyAttribute.Setting IsReference on JsonObjectAttribute or JsonArrayAttribute to
true will mean the JsonSerializer will always serialize the type the
attribute is against as a reference. Setting IsReference on the
JsonPropertyAttribute to true will serialize only that property as a
reference.IReferenceResolverTo customize how references are generated and resolved the
T:Newtonsoft.Json.Serialization.IReferenceResolver
interface is available to inherit from and use with
the JsonSerializer.T:Newtonsoft.Json.PreserveReferencesHandling
================================================
FILE: Doc/QueryingLINQtoJSON.aml
================================================
LINQ to JSON provides a number of methods for getting data from its objects. The index methods on JObject/JArray let you quickly get data by its property name
on an object or index in a collection, while M:Newtonsoft.Json.Linq.JToken.Children lets you get ranges
of data as IEnumerable<JToken> to then query using LINQ.Getting values by Property Name or Collection IndexThe simplest way to get a value from LINQ to JSON is to use the
P:Newtonsoft.Json.Linq.JToken.Item(System.Object) index on
JObject/JArray and then cast the returned T:Newtonsoft.Json.Linq.JValue to the type you want.
Querying with LINQJObject/JArray can also be queried using LINQ. M:Newtonsoft.Json.Linq.JToken.Children
returns the children values of a JObject/JArray
as an IEnumerable<JToken> that can then be queried with the standard Where/OrderBy/Select LINQ operators.M:Newtonsoft.Json.Linq.JToken.Children returns all the children of a token. If it is a
JObject it will return a collection of properties to work with, and if
it is a JArray you will get a collection of the array's values.LINQ to JSON can also be used to manually convert JSON to a .NET object.Manually serializing and deserializing between .NET objects is useful when you are
working with JSON that doesn't closely match your .NET objects.P:Newtonsoft.Json.Linq.JToken.Item(System.Object)M:Newtonsoft.Json.Linq.JToken.Children
================================================
FILE: Doc/ReadingWritingJSON.aml
================================================
To manually read and write JSON, Json.NET provides the
T:Newtonsoft.Json.JsonReader
and
T:Newtonsoft.Json.JsonWriter classes.JsonTextReader and JsonTextWriterJsonReader and JsonWriter are low-level classes and are primarily for internal use by Json.NET.
To quickly work with JSON, either the serializer - - or using is recommended.
T:Newtonsoft.Json.JsonTextReader
and T:Newtonsoft.Json.JsonTextWriter
are used to read and write JSON text.
The JsonTextWriter has a number of settings on it to control how JSON is formatted
when it is written. These options include formatting, indentation character, indent
count, and quote character.JsonTextReader has settings on it for reading different date formats, time zones, and
the cultures when reading text values.JTokenReader and JTokenWriterT:Newtonsoft.Json.Linq.JTokenReader
and T:Newtonsoft.Json.Linq.JTokenWriter
read and write LINQ to JSON objects. They are located in the
N:Newtonsoft.Json.Linq
namespace. These objects allow you to use LINQ to JSON objects with objects that
read and write JSON, such as the JsonSerializer. For example you can deserialize
from a LINQ to JSON object into a regular .NET object and vice versa.T:Newtonsoft.Json.JsonReaderT:Newtonsoft.Json.JsonWriterT:Newtonsoft.Json.Linq.JTokenReaderT:Newtonsoft.Json.Linq.JTokenWriterT:Newtonsoft.Json.Bson.BsonReaderT:Newtonsoft.Json.Bson.BsonWriter
================================================
FILE: Doc/ReducingSerializedJSONSize.aml
================================================
One of the common problems encountered when serializing .NET objects to
JSON is that the JSON ends up containing a lot of unwanted properties and values.
This can be especially significant when returning JSON to the client. More JSON
means more bandwidth and a slower website.To solve the issue of unwanted JSON, Json.NET has a range of built-in
options to fine-tune what gets written from a serialized object.JsonIgnoreAttribute and DataMemberAttributeBy default Json.NET will include all of a class's public properties and fields
in the JSON it creates. Adding the
T:Newtonsoft.Json.JsonIgnoreAttribute
to a property tells the serializer to always skip writing it to the JSON result.If a class has many properties and you only want to serialize a small subset
of them, then adding JsonIgnore to all the others will be tedious and error prone.
The way to tackle this scenario is to add the
T:System.Runtime.Serialization.DataContractAttribute
to the class and
T:System.Runtime.Serialization.DataMemberAttribute
to the properties to serialize. This is opt-in
serialization - only the properties you mark up will be serialized, unlike
opt-out serialization using JsonIgnoreAttribute.FormattingJSON written by the serializer with an option of
T:Newtonsoft.Json.Formatting
set to Indented produces
nicely formatted, easy-to-read JSON that is great for readability when you are
developing. Formatting.None on the other hand keeps the JSON result small, skipping
all unnecessary spaces and line breaks to produce the most compact and efficient
JSON possible.NullValueHandlingT:Newtonsoft.Json.NullValueHandling
is an option on the JsonSerializer and controls how the
serializer handles properties with a null value. By setting a value of
NullValueHandling.Ignore the JsonSerializer skips writing any properties that have
a value of null.NullValueHandling can also be customized on individual properties
using the
T:Newtonsoft.Json.JsonPropertyAttribute.
The JsonPropertyAttribute value of
NullValueHandling will override the setting on the JsonSerializer for that
property.DefaultValueHandlingT:Newtonsoft.Json.DefaultValueHandling
is an option on the JsonSerializer and controls how the serializer handles
properties with a default value. Setting a value of DefaultValueHandling.Ignore
will make the JsonSerializer skip writing any properties that have a default
value to the JSON result. For object references this will be null. For value
types like int and DateTime the serializer will skip the default uninitialized
value for that value type.Json.NET also allows you to customize what the default value of an individual
property is using the
T:System.ComponentModel.DefaultValueAttribute.
For example, if a string property called
Department always returns an empty string in its default state and you don't want
that empty string in your JSON, then placing the DefaultValueAttribute on Department
with that value will mean Department is no longer written to JSON unless it has a
value.DefaultValueHandling can also be customized on individual properties using
the T:Newtonsoft.Json.JsonPropertyAttribute.
The JsonPropertyAttribute value of DefaultValueHandling
will override the setting on the JsonSerializer for that property.IContractResolverFor more flexibility, the
T:Newtonsoft.Json.Serialization.IContractResolver
provides an interface to customize
almost every aspect of how a .NET object gets serialized to JSON, including changing
serialization behavior at runtime.T:Newtonsoft.Json.FormattingT:Newtonsoft.Json.JsonIgnoreAttributeT:Newtonsoft.Json.DefaultValueHandlingT:Newtonsoft.Json.NullValueHandling
================================================
FILE: Doc/Samples/Bson/DeserializeFromBson.aml
================================================
This sample deserializes BSON to an object.Sample
================================================
FILE: Doc/Samples/Bson/DeserializeFromBsonCollection.aml
================================================
This sample sets P:Newtonsoft.Json.Bson.BsonReader.ReadRootValueAsArray
to true so the root BSON value is correctly read
as an array instead of an object and deserializes BSON to a collection.Sample
================================================
FILE: Doc/Samples/Bson/SerializeToBson.aml
================================================
This sample serializes an object to BSON.Sample
================================================
FILE: Doc/Samples/Json/CustomJsonReader.aml
================================================
This sample creates a custom T:Newtonsoft.Json.JsonReader.Sample
================================================
FILE: Doc/Samples/Json/CustomJsonWriter.aml
================================================
This sample creates a custom T:Newtonsoft.Json.JsonWriter.Sample
================================================
FILE: Doc/Samples/Json/ReadJsonWithJsonTextReader.aml
================================================
This sample reads JSON using the T:Newtonsoft.Json.JsonTextReader.Sample
================================================
FILE: Doc/Samples/Json/ReadMultipleContentWithJsonReader.aml
================================================
This sample sets P:Newtonsoft.Json.JsonReader.SupportMultipleContent
to true so that multiple JSON fragments can be read from a T:System.IO.Stream or
T:System.IO.TextReader.Sample
================================================
FILE: Doc/Samples/Json/WriteJsonWithJsonTextWriter.aml
================================================
This sample writes JSON using the T:Newtonsoft.Json.JsonTextWriter.Sample
================================================
FILE: Doc/Samples/JsonPath/ErrorWhenNoMatchQuery.aml
================================================
This sample loads JSON and then queries values from it using Overload:Newtonsoft.Json.Linq.JToken.SelectToken. An error is thrown when part of the JSON path is not found.Sample
================================================
FILE: Doc/Samples/JsonPath/QueryJsonSelectToken.aml
================================================
This sample loads JSON and then queries values from it using M:Newtonsoft.Json.Linq.JToken.SelectToken(System.String).Sample
================================================
FILE: Doc/Samples/JsonPath/QueryJsonSelectTokenEscaped.aml
================================================
This sample loads JSON with properties that need to be escaped when queried with M:Newtonsoft.Json.Linq.JToken.SelectToken(System.String).Sample
================================================
FILE: Doc/Samples/JsonPath/QueryJsonSelectTokenJsonPath.aml
================================================
This sample loads JSON and then queries values from it using M:Newtonsoft.Json.Linq.JToken.SelectToken(System.String) with a JSONPathhttp://stackoverflow.com/tags/jsonpath_blank query.Sample
================================================
FILE: Doc/Samples/JsonPath/QueryJsonSelectTokenWithLinq.aml
================================================
This sample loads JSON and then queries values from it using a combination of M:Newtonsoft.Json.Linq.JToken.SelectToken(System.String)
and LINQ operators.Sample
================================================
FILE: Doc/Samples/JsonPath/RegexQuery.aml
================================================
This sample loads JSON and then queries values from it using M:Newtonsoft.Json.Linq.JToken.SelectToken(System.String) with a regex JSON Path.Sample
================================================
FILE: Doc/Samples/JsonPath/StrictEqualsQuery.aml
================================================
This sample loads JSON and then queries values from it using M:Newtonsoft.Json.Linq.JToken.SelectToken(System.String) with a strict equals JSON Path.Sample
================================================
FILE: Doc/Samples/Linq/Clone.aml
================================================
This sample recursively clones a T:Newtonsoft.Json.Linq.JToken
and all its children using M:Newtonsoft.Json.Linq.JToken.DeepClone.Sample
================================================
FILE: Doc/Samples/Linq/CreateJsonAnonymousObject.aml
================================================
This sample creates a T:Newtonsoft.Json.Linq.JObject
from an anonymous type.Sample
================================================
FILE: Doc/Samples/Linq/CreateJsonCollectionInitializer.aml
================================================
This sample creates T:Newtonsoft.Json.Linq.JObject
and T:Newtonsoft.Json.Linq.JArray instances using
the C# collection initializer syntax.Sample
================================================
FILE: Doc/Samples/Linq/CreateJsonDeclaratively.aml
================================================
This sample creates T:Newtonsoft.Json.Linq.JObject
and T:Newtonsoft.Json.Linq.JArray instances declaratively
using LINQ.Sample
================================================
FILE: Doc/Samples/Linq/CreateJsonDynamic.aml
================================================
This sample creates T:Newtonsoft.Json.Linq.JObject
and T:Newtonsoft.Json.Linq.JArray instances using
the C# dynamic functionality.Sample
================================================
FILE: Doc/Samples/Linq/CreateJsonJTokenWriter.aml
================================================
This sample creates T:Newtonsoft.Json.Linq.JObject
and T:Newtonsoft.Json.Linq.JArray instances using
a T:Newtonsoft.Json.Linq.JTokenWriter.Sample
================================================
FILE: Doc/Samples/Linq/CreateJsonManually.aml
================================================
This sample creates T:Newtonsoft.Json.Linq.JObject
and T:Newtonsoft.Json.Linq.JArray instances one at a time
programatically.Sample
================================================
FILE: Doc/Samples/Linq/CreateReader.aml
================================================
This sample creates a T:Newtonsoft.Json.Linq.JTokenReader
from a T:Newtonsoft.Json.Linq.JToken.Sample
================================================
FILE: Doc/Samples/Linq/CreateWriter.aml
================================================
This sample creates a T:Newtonsoft.Json.Linq.JTokenWriter
from a T:Newtonsoft.Json.Linq.JToken.Sample
================================================
FILE: Doc/Samples/Linq/DeepEquals.aml
================================================
This sample compares T:Newtonsoft.Json.Linq.JToken
instances using M:Newtonsoft.Json.Linq.JToken.DeepEquals(Newtonsoft.Json.Linq.JToken,Newtonsoft.Json.Linq.JToken),
comparing the token and all child tokens.Sample
================================================
FILE: Doc/Samples/Linq/DeserializeWithLinq.aml
================================================
This sample uses LINQ to JSON to manually convert JSON to a .NET type.Sample
================================================
FILE: Doc/Samples/Linq/FromObject.aml
================================================
This sample converts .NET values to LINQ to JSON using
M:Newtonsoft.Json.Linq.JToken.FromObject(System.Object).Sample
================================================
FILE: Doc/Samples/Linq/JObjectProperties.aml
================================================
This sample gets an object's T:Newtonsoft.Json.Linq.JProperty
collection using M:Newtonsoft.Json.Linq.JObject.Properties.Sample
================================================
FILE: Doc/Samples/Linq/JTokenAnnotation.aml
================================================
This sample uses annotations with LINQ to JSON objects.Sample
================================================
FILE: Doc/Samples/Linq/JValueCast.aml
================================================
This sample casts T:Newtonsoft.Json.Linq.JValue
instances to .NET values.Sample
================================================
FILE: Doc/Samples/Linq/JValueValue.aml
================================================
This sample gets T:Newtonsoft.Json.Linq.JValue
internal values using P:Newtonsoft.Json.Linq.JValue.Value.Sample
================================================
FILE: Doc/Samples/Linq/MergeJson.aml
================================================
This sample merges LINQ to JSON objects.Sample
================================================
FILE: Doc/Samples/Linq/ModifyJson.aml
================================================
This sample loads JSON, modifies T:Newtonsoft.Json.Linq.JObject
and T:Newtonsoft.Json.Linq.JArray
instances and then writes the JSON back out again.Sample
================================================
FILE: Doc/Samples/Linq/ParseJsonAny.aml
================================================
This sample parses JSON using
M:Newtonsoft.Json.Linq.JToken.Parse(System.String).Sample
================================================
FILE: Doc/Samples/Linq/ParseJsonArray.aml
================================================
This sample parses a JSON array using
M:Newtonsoft.Json.Linq.JArray.Parse(System.String).Sample
================================================
FILE: Doc/Samples/Linq/ParseJsonObject.aml
================================================
This sample parses a JSON object using
M:Newtonsoft.Json.Linq.JObject.Parse(System.String).Sample
================================================
FILE: Doc/Samples/Linq/QueryJson.aml
================================================
This sample loads JSON and then queries values from it using
P:Newtonsoft.Json.Linq.JToken.Item(System.Object)
indexer and then casts the returned tokens to .NET values.Sample
================================================
FILE: Doc/Samples/Linq/QueryJsonDynamic.aml
================================================
This sample loads JSON and then queries values from it using
C# dynamic functionality.Sample
================================================
FILE: Doc/Samples/Linq/QueryJsonLinq.aml
================================================
This sample loads JSON and then queries values from it using LINQ operators.Sample
================================================
FILE: Doc/Samples/Linq/ReadJTokenFromBson.aml
================================================
This sample reads a T:Newtonsoft.Json.Linq.JObject
from BSON using T:Newtonsoft.Json.Bson.BsonReader.Sample
================================================
FILE: Doc/Samples/Linq/ReadJson.aml
================================================
This sample reads JSON from a file into a T:Newtonsoft.Json.Linq.JObject.Sample
================================================
FILE: Doc/Samples/Linq/SerializeWithLinq.aml
================================================
This sample uses LINQ to JSON to manually convert a .NET type to JSON.Sample
================================================
FILE: Doc/Samples/Linq/ToObjectComplex.aml
================================================
This sample converts LINQ to JSON objects to .NET types using
M:Newtonsoft.Json.Linq.JToken.ToObject``1.Sample
================================================
FILE: Doc/Samples/Linq/ToObjectGeneric.aml
================================================
This sample converts LINQ to JSON objects to .NET types using
M:Newtonsoft.Json.Linq.JToken.ToObject``1.Sample
================================================
FILE: Doc/Samples/Linq/ToObjectType.aml
================================================
This sample converts LINQ to JSON objects to .NET types using
M:Newtonsoft.Json.Linq.JToken.ToObject(System.Type).Sample
================================================
FILE: Doc/Samples/Linq/ToString.aml
================================================
This sample converts LINQ to JSON objects to JSON.Sample
================================================
FILE: Doc/Samples/Linq/ToStringJsonConverter.aml
================================================
This sample uses a T:Newtonsoft.Json.JsonConverter
to customize converting LINQ to JSON objects to JSON.Sample
================================================
FILE: Doc/Samples/Linq/WriteJTokenToBson.aml
================================================
This sample writes a T:Newtonsoft.Json.Linq.JObject
to BSON using T:Newtonsoft.Json.Bson.BsonWriter.Sample
================================================
FILE: Doc/Samples/Linq/WriteToJsonFile.aml
================================================
This sample writes LINQ to JSON objects to a file.Sample
================================================
FILE: Doc/Samples/Samples.aml
================================================
Over 100 code samples covering Json.NET's most commonly used functionality.SamplesSerializing JSON - Serializing and deserializing JSON, serializer settings and serialization attributesLINQ to JSON - Parsing, querying, modifying and writing JSONJSON Schema - Loading schemas and validating JSON. Note that JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschemahttps://www.newtonsoft.com/jsonschema_blank
for more details.Converting XML - Converting JSON to XML and XML to JSONBSON - Serializing and deserializing BSONReading and Writing JSON - Reading JSON with JsonTextReader, writing JSON with JsonTextWriter
================================================
FILE: Doc/Samples/Schema/CreateJsonSchemaManually.aml
================================================
This sample creates a new T:Newtonsoft.Json.Schema.JsonSchema
instance manually in code.Obsolete. JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschemahttps://www.newtonsoft.com/jsonschema_blank
for more details.
Sample
================================================
FILE: Doc/Samples/Schema/JTokenIsValid.aml
================================================
This sample validates a T:Newtonsoft.Json.Linq.JObject
using the M:Newtonsoft.Json.Schema.Extensions.IsValid(Newtonsoft.Json.Linq.JToken,Newtonsoft.Json.Schema.JsonSchema)
extension method.Obsolete. JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschemahttps://www.newtonsoft.com/jsonschema_blank
for more details.
Sample
================================================
FILE: Doc/Samples/Schema/JTokenIsValidWithMessages.aml
================================================
This sample validates a T:Newtonsoft.Json.Linq.JObject
using the M:Newtonsoft.Json.Schema.Extensions.IsValid(Newtonsoft.Json.Linq.JToken,Newtonsoft.Json.Schema.JsonSchema)
extension method and returns error messages.Obsolete. JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschemahttps://www.newtonsoft.com/jsonschema_blank
for more details.
Sample
================================================
FILE: Doc/Samples/Schema/JTokenValidateWithEvent.aml
================================================
This sample validates a T:Newtonsoft.Json.Linq.JObject
using the M:Newtonsoft.Json.Schema.Extensions.IsValid(Newtonsoft.Json.Linq.JToken,Newtonsoft.Json.Schema.JsonSchema)
extension method and raises an event for each validation error.Obsolete. JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschemahttps://www.newtonsoft.com/jsonschema_blank
for more details.
Sample
================================================
FILE: Doc/Samples/Schema/JsonSchemaParse.aml
================================================
This sample parses a T:Newtonsoft.Json.Schema.JsonSchema
from JSONObsolete. JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschemahttps://www.newtonsoft.com/jsonschema_blank
for more details.
Sample
================================================
FILE: Doc/Samples/Schema/JsonValidatingReaderAndSerializer.aml
================================================
This sample validates JSON while deserializing an object using
T:Newtonsoft.Json.JsonValidatingReader.Obsolete. JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschemahttps://www.newtonsoft.com/jsonschema_blank
for more details.
Sample
================================================
FILE: Doc/Samples/Schema/LoadJsonSchemaFromFile.aml
================================================
This sample loads a T:Newtonsoft.Json.Schema.JsonSchema
from a file.Obsolete. JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschemahttps://www.newtonsoft.com/jsonschema_blank
for more details.
Sample
================================================
FILE: Doc/Samples/Schema/RefJsonSchemaResolver.aml
================================================
This sample uses a T:Newtonsoft.Json.Schema.JsonSchemaResolver
to resolve schema references from different JSON documents.Obsolete. JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschemahttps://www.newtonsoft.com/jsonschema_blank
for more details.
Sample
================================================
FILE: Doc/Samples/Schema/SaveJsonSchemaToFile.aml
================================================
This sample saves a T:Newtonsoft.Json.Schema.JsonSchema
to a file.Obsolete. JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschemahttps://www.newtonsoft.com/jsonschema_blank
for more details.
Sample
================================================
FILE: Doc/Samples/Serializer/CustomContractResolver.aml
================================================
This sample creates a custom T:Newtonsoft.Json.Serialization.IContractResolver
that only serializes a type's properties that begin with a specified character.Sample
================================================
FILE: Doc/Samples/Serializer/CustomJsonConverter.aml
================================================
This sample creates a custom T:Newtonsoft.Json.JsonConverter
that overrides serialization to add a keys property.Sample
================================================
FILE: Doc/Samples/Serializer/CustomJsonConverterGeneric.aml
================================================
This sample creates a custom converter from JsonConverter<T>
that overrides serialization for the Version class with a custom display string.Sample
================================================
FILE: Doc/Samples/Serializer/CustomTraceWriter.aml
================================================
This sample creates a custom T:Newtonsoft.Json.Serialization.ITraceWriter
that writes to
NLoghttp://nlog-project.org/_blank.Sample
================================================
FILE: Doc/Samples/Serializer/DataContractAndDataMember.aml
================================================
This sample shows how .NET Framework attributes such as
T:System.Runtime.Serialization.DataContractAttribute,
T:System.Runtime.Serialization.DataMemberAttribute and
T:System.NonSerializedAttribute
can be used with Json.NET instead of Json.NET's own attributes.Sample
================================================
FILE: Doc/Samples/Serializer/DefaultSettings.aml
================================================
This sample serializes and deserializes JSON using P:Newtonsoft.Json.JsonConvert.DefaultSettings.Sample
================================================
FILE: Doc/Samples/Serializer/DefaultValueAttributeIgnore.aml
================================================
This sample uses the T:System.ComponentModel.DefaultValueAttribute
to override the default value for a property and exclude it from serialization using
T:Newtonsoft.Json.DefaultValueHandling.Sample
================================================
FILE: Doc/Samples/Serializer/DefaultValueHandlingIgnore.aml
================================================
This sample uses the T:Newtonsoft.Json.DefaultValueHandling setting to
not serialize properties with a default value.Sample
================================================
FILE: Doc/Samples/Serializer/DeserializeAnonymousType.aml
================================================
This sample deserializes JSON into an anonymous type.Sample
================================================
FILE: Doc/Samples/Serializer/DeserializeCollection.aml
================================================
This sample deserializes JSON into a collection.Sample
================================================
FILE: Doc/Samples/Serializer/DeserializeConstructorHandling.aml
================================================
This sample uses the T:Newtonsoft.Json.ConstructorHandling setting to
successfully deserialize the class using its non-public constructor.Sample
================================================
FILE: Doc/Samples/Serializer/DeserializeCustomCreationConverter.aml
================================================
This sample creates a class that inherits from T:Newtonsoft.Json.Converters.CustomCreationConverter`1
that instantiates Employee instances for the Person type.Sample
================================================
FILE: Doc/Samples/Serializer/DeserializeDataSet.aml
================================================
This sample deserializes JSON to a T:System.Data.DataSet.Sample
================================================
FILE: Doc/Samples/Serializer/DeserializeDateFormatString.aml
================================================
This sample uses the DateFormatString
setting to control how T:System.DateTime and T:System.DateTimeOffset are deserialized.Sample
================================================
FILE: Doc/Samples/Serializer/DeserializeDictionary.aml
================================================
This sample deserializes JSON into a dictionary.Sample
================================================
FILE: Doc/Samples/Serializer/DeserializeExtensionData.aml
================================================
This sample deserializes JSON to an object with extension data.Sample
================================================
FILE: Doc/Samples/Serializer/DeserializeImmutableCollections.aml
================================================
This sample deserializes JSON into an immutable collection.Sample
================================================
FILE: Doc/Samples/Serializer/DeserializeMetadataPropertyHandling.aml
================================================
This sample deserializes JSON with T:Newtonsoft.Json.MetadataPropertyHandling
set to ReadAhead so that metadata properties do not need to be at the start of an object.Sample
================================================
FILE: Doc/Samples/Serializer/DeserializeMissingMemberHandling.aml
================================================
This sample attempts to deserialize JSON with T:Newtonsoft.Json.MissingMemberHandling
set to error and a JSON property that doesn't match to a member, causing an exception.Sample
================================================
FILE: Doc/Samples/Serializer/DeserializeObject.aml
================================================
This sample deserializes JSON to an object.Sample
================================================
FILE: Doc/Samples/Serializer/DeserializeObjectCreationHandling.aml
================================================
This sample deserializes JSON with T:Newtonsoft.Json.ObjectCreationHandling
set to Replace so that collection values aren't duplicated.Sample
================================================
FILE: Doc/Samples/Serializer/DeserializeWithDependencyInjection.aml
================================================
This sample deserializes JSON using dependency injection.Sample
================================================
FILE: Doc/Samples/Serializer/DeserializeWithJsonSerializerFromFile.aml
================================================
This sample deserializes JSON retrieved from a file.Sample
================================================
FILE: Doc/Samples/Serializer/ErrorHandlingAttribute.aml
================================================
This sample uses T:Newtonsoft.Json.Serialization.OnErrorAttribute to ignore the exception thrown setting the Roles property.Sample
================================================
FILE: Doc/Samples/Serializer/ErrorHandlingEvent.aml
================================================
This sample uses the P:Newtonsoft.Json.JsonSerializerSettings.Error event
to ignore the exceptions thrown from the invalid date strings.Sample
================================================
FILE: Doc/Samples/Serializer/JsonConstructorAttribute.aml
================================================
This sample uses the
T:Newtonsoft.Json.JsonConstructorAttribute
to specify that a constructor should be used to create a class during deserialization.Sample
================================================
FILE: Doc/Samples/Serializer/JsonConverterAttributeClass.aml
================================================
This sample uses the
T:Newtonsoft.Json.JsonConverterAttribute
to specify that a T:Newtonsoft.Json.JsonConverter
should be used when serializing and deserializing a class.Sample
================================================
FILE: Doc/Samples/Serializer/JsonConverterAttributeProperty.aml
================================================
This sample uses the
T:Newtonsoft.Json.JsonConverterAttribute
to specify that a T:Newtonsoft.Json.JsonConverter
should be used when serializing and deserializing a property.Sample
================================================
FILE: Doc/Samples/Serializer/JsonObjectAttributeOptIn.aml
================================================
This sample uses
T:Newtonsoft.Json.JsonObjectAttribute
and T:Newtonsoft.Json.MemberSerialization to specify that
only properties that have been explicitly specified with T:Newtonsoft.Json.JsonPropertyAttribute
should be serialized.Sample
================================================
FILE: Doc/Samples/Serializer/JsonObjectAttributeOverrideIEnumerable.aml
================================================
This sample uses T:Newtonsoft.Json.JsonObjectAttribute
to serialize a class that implements T:System.Collections.Generic.IEnumerable`1 as
a JSON object instead of a JSON array.Sample
================================================
FILE: Doc/Samples/Serializer/JsonPropertyItemLevelSetting.aml
================================================
This sample uses T:Newtonsoft.Json.JsonPropertyAttribute
to change how the property value's items are serialized,
e.g. setting ItemIsReference to true on a property with a collection will serialize all the collection's items
with reference tracking enabled.Sample
================================================
FILE: Doc/Samples/Serializer/JsonPropertyName.aml
================================================
This sample uses T:Newtonsoft.Json.JsonPropertyAttribute
to change the names of properties when they are serialized to JSON.Sample
================================================
FILE: Doc/Samples/Serializer/JsonPropertyOrder.aml
================================================
This sample uses T:Newtonsoft.Json.JsonPropertyAttribute
to order of properties when they are serialized to JSON.Sample
================================================
FILE: Doc/Samples/Serializer/JsonPropertyPropertyLevelSetting.aml
================================================
This sample uses T:Newtonsoft.Json.JsonPropertyAttribute
to change how the property value is serialized.Sample
================================================
FILE: Doc/Samples/Serializer/JsonPropertyRequired.aml
================================================
This sample uses T:Newtonsoft.Json.JsonPropertyAttribute
to set T:Newtonsoft.Json.Required which is used during deserialization
to validate the presence of required JSON properties.Sample
================================================
FILE: Doc/Samples/Serializer/MaxDepth.aml
================================================
This sample uses the P:Newtonsoft.Json.JsonSerializerSettings.MaxDepth setting to constrain JSON
to a maximum depth when deserializing.Sample
================================================
FILE: Doc/Samples/Serializer/NamingStrategyAttributes.aml
================================================
This sample uses T:Newtonsoft.Json.Serialization.NamingStrategy
types specified on attributes to control serialized property names.Sample
================================================
FILE: Doc/Samples/Serializer/NamingStrategyCamelCase.aml
================================================
This sample uses a T:Newtonsoft.Json.Serialization.CamelCaseNamingStrategy
specified using a contract resolver to camel case serialized property names.Sample
================================================
FILE: Doc/Samples/Serializer/NamingStrategySkipDictionaryKeys.aml
================================================
This sample configures a T:Newtonsoft.Json.Serialization.CamelCaseNamingStrategy
to not camel case dictionary keys.Sample
================================================
FILE: Doc/Samples/Serializer/NamingStrategySkipSpecifiedNames.aml
================================================
This sample configures a T:Newtonsoft.Json.Serialization.CamelCaseNamingStrategy
to not camel case properties that already have a name specified with an attribute.Sample
================================================
FILE: Doc/Samples/Serializer/NamingStrategySnakeCase.aml
================================================
This sample uses a T:Newtonsoft.Json.Serialization.SnakeCaseNamingStrategy
specified using a contract resolver to snake case serialized property names.Sample
================================================
FILE: Doc/Samples/Serializer/NullValueHandlingIgnore.aml
================================================
This sample serializes an object to JSON with T:Newtonsoft.Json.NullValueHandling
set to Ignore so that properties with a default value of null aren't included in the JSON result.Sample
================================================
FILE: Doc/Samples/Serializer/PopulateObject.aml
================================================
This sample populates an existing object instance with values from JSON.Sample
================================================
FILE: Doc/Samples/Serializer/PreserveReferencesHandlingObject.aml
================================================
This sample shows how the T:Newtonsoft.Json.PreserveReferencesHandling
setting can be used to serialize values by reference instead of by value.Sample
================================================
FILE: Doc/Samples/Serializer/PropertyJsonIgnore.aml
================================================
This sample uses the T:Newtonsoft.Json.JsonIgnoreAttribute
to exclude a property from serialization.Sample
================================================
FILE: Doc/Samples/Serializer/ReferenceLoopHandlingIgnore.aml
================================================
This sample sets T:Newtonsoft.Json.ReferenceLoopHandling
to Ignore so that looping values are excluded from serialization instead of throwing an exception.Sample
================================================
FILE: Doc/Samples/Serializer/SerializationCallbackAttributes.aml
================================================
This sample uses serialization callback attributes
(T:System.Runtime.Serialization.OnSerializingAttribute,
T:System.Runtime.Serialization.OnSerializedAttribute,
T:System.Runtime.Serialization.OnDeserializingAttribute,
T:System.Runtime.Serialization.OnDeserializedAttribute)
to manipulate an object before and after its serialization and deserialization.Sample
================================================
FILE: Doc/Samples/Serializer/SerializeCollection.aml
================================================
This sample serializes a collection to JSON.Sample
================================================
FILE: Doc/Samples/Serializer/SerializeConditionalProperty.aml
================================================
This sample uses a conditional property to exclude a property from serialization.Sample
================================================
FILE: Doc/Samples/Serializer/SerializeContractResolver.aml
================================================
This sample uses a custom T:Newtonsoft.Json.Serialization.IContractResolver
to modify how objects are serialized.Sample
================================================
FILE: Doc/Samples/Serializer/SerializeDataSet.aml
================================================
This sample serializes a T:System.Data.DataSet to JSON.Sample
================================================
FILE: Doc/Samples/Serializer/SerializeDateFormatHandling.aml
================================================
This sample uses the T:Newtonsoft.Json.DateFormatHandling
setting to control how T:System.DateTime and T:System.DateTimeOffset are serialized.Sample
================================================
FILE: Doc/Samples/Serializer/SerializeDateFormatString.aml
================================================
This sample uses the DateFormatString
setting to control how T:System.DateTime and T:System.DateTimeOffset are serialized.Sample
================================================
FILE: Doc/Samples/Serializer/SerializeDateTimeZoneHandling.aml
================================================
This sample uses the T:Newtonsoft.Json.DateTimeZoneHandling
setting to control how T:System.DateTime and T:System.DateTimeOffset are serialized.Sample
================================================
FILE: Doc/Samples/Serializer/SerializeDictionary.aml
================================================
This sample serializes a dictionary to JSON.Sample
================================================
FILE: Doc/Samples/Serializer/SerializeExtensionData.aml
================================================
This sample serializes an object with extension data into JSON.Sample
================================================
FILE: Doc/Samples/Serializer/SerializeImmutableCollections.aml
================================================
This sample serializes an immutable collection into JSON.Sample
================================================
FILE: Doc/Samples/Serializer/SerializeObject.aml
================================================
This sample serializes an object to JSON.Sample
================================================
FILE: Doc/Samples/Serializer/SerializeRawJson.aml
================================================
This sample uses T:Newtonsoft.Json.Linq.JRaw
properties to serialize JSON with raw content.Sample
================================================
FILE: Doc/Samples/Serializer/SerializeSerializationBinder.aml
================================================
This sample creates a custom T:System.Runtime.Serialization.SerializationBinder
that writes only the type name when including type data in JSON.Sample
================================================
FILE: Doc/Samples/Serializer/SerializeTypeNameHandling.aml
================================================
This sample uses the T:Newtonsoft.Json.TypeNameHandling
setting to include type information when serializing JSON and read type information so that the correct types are created when deserializing JSON.Sample
================================================
FILE: Doc/Samples/Serializer/SerializeUnindentedJson.aml
================================================
This sample serializes an object to JSON without any formatting or indentation whitespace.Sample
================================================
FILE: Doc/Samples/Serializer/SerializeWithJsonConverters.aml
================================================
This sample uses a T:Newtonsoft.Json.JsonConverter
to customize how JSON is serialized.Sample
================================================
FILE: Doc/Samples/Serializer/SerializeWithJsonSerializerToFile.aml
================================================
This sample serializes JSON to a file.Sample
================================================
FILE: Doc/Samples/Serializer/TraceWriter.aml
================================================
This sample uses an T:Newtonsoft.Json.Serialization.ITraceWriter
to log debug information from serialization.Sample
================================================
FILE: Doc/Samples/Xml/ConvertJsonToXml.aml
================================================
This sample converts JSON to XML.Sample
================================================
FILE: Doc/Samples/Xml/ConvertXmlToJson.aml
================================================
This sample converts XML to JSON.Sample
================================================
FILE: Doc/Samples/Xml/ConvertXmlToJsonForceArray.aml
================================================
This sample reads the json:Array="true" attribute in the XML and places its value in an array
when converting the XML to JSON.Sample
================================================
FILE: Doc/SelectToken.aml
================================================
Overload:Newtonsoft.Json.Linq.JToken.SelectToken
provides a method to query LINQ to JSON using a single string path to a desired
T:Newtonsoft.Json.Linq.JToken.
SelectToken makes dynamic queries easy because the entire query is defined in a string.SelectTokenSelectToken is a method on JToken and takes a string path to a child token.
SelectToken returns the child token or a null reference if a token couldn't be
found at the path's location.The path is made up of property names and array indexes separated by periods,
e.g. Manufacturers[0].Name.SelectToken with JSONPathSelectToken supports JSONPath queries. Find out more about JSONPath herehttps://goessner.net/articles/JsonPath/_blank.SelectToken with LINQSelectToken can be used in combination with standard LINQ methods.Overload:Newtonsoft.Json.Linq.JToken.SelectToken
================================================
FILE: Doc/SerializationAttributes.aml
================================================
Attributes can be used to control how Json.NET serializes and deserializes .NET objects.T:Newtonsoft.Json.JsonObjectAttribute - Placed on classes to control how they should be serialized as a JSON object.T:Newtonsoft.Json.JsonArrayAttribute - Placed on collections to control how they should be serialized as a JSON array.T:Newtonsoft.Json.JsonDictionaryAttribute - Placed on dictionaries to control how they should be serialized as a JSON object.T:Newtonsoft.Json.JsonPropertyAttribute - Placed on fields and properties to control how they should be serialized as a property in a JSON object.T:Newtonsoft.Json.JsonConverterAttribute - Placed on either classes or fields and properties to specify which JsonConverter should be used during serialization.T:Newtonsoft.Json.JsonExtensionDataAttribute - Placed on a collection field or property to deserialize properties with no matching class member into the specified collection and write values during serialization.T:Newtonsoft.Json.JsonConstructorAttribute - Placed on a constructor to specify that it should be used to create the class during deserialization.Standard .NET Serialization AttributesAs well as using the built-in Json.NET attributes, Json.NET also looks for the T:System.SerializableAttribute
(if IgnoreSerializableAttribute on DefaultContractResolver is set to false)
T:System.Runtime.Serialization.DataContractAttribute,
T:System.Runtime.Serialization.DataMemberAttribute,
and T:System.NonSerializedAttribute and attributes when determining how JSON is to be serialized and deserialized.
Json.NET attributes take precedence over standard .NET serialization attributes (e.g. if both JsonPropertyAttribute
and DataMemberAttribute are present on a property and both customize the name,
the name from JsonPropertyAttribute will be used).Json.NET Serialization AttributesJsonObjectAttributeThe MemberSerialization flag on this attribute specifies whether member serialization is opt-in
(a member must have the JsonProperty or DataMember attribute to be serialized), opt-out (everything is
serialized by default but can be ignored with the JsonIgnoreAttribute, Json.NET's default behavior) or
fields (all public and private fields are serialized and properties are ignored).Placing the the T:System.Runtime.Serialization.DataContractAttribute
on a type is another way to default member serialization to opt-in.The NamingStrategy setting on this attributes can be set to a T:Newtonsoft.Json.Serialization.NamingStrategy
type that specifies how property names are serialized.Json.NET serializes .NET classes that implement IEnumerable as a JSON array populated with the
IEnumerable values. Placing the T:Newtonsoft.Json.JsonObjectAttribute
overrides this behavior and forces the serializer to serialize the class's fields and properties.JsonArrayAttribute/JsonDictionaryAttributeThe T:Newtonsoft.Json.JsonArrayAttribute and
T:Newtonsoft.Json.JsonDictionaryAttribute are used to specify
whether a class is serialized as that collection type.The collection attributes have options to customize the JsonConverter, type name handling, and reference handling that are applied to collection items.JsonPropertyAttributeJsonPropertyAttribute has a number of uses:By default, the JSON property will have the same name as the .NET property. This attribute allows the name to be customized.JsonPropertyAttribute indicates that a property should be serialized when member serialization is set to opt-in.It includes non-public properties in serialization and deserialization.It can be used to customize type name, reference, null, and default value handling for the property value.It can be used to customize the T:Newtonsoft.Json.Serialization.NamingStrategy of the serialized property name.It can be used to customize the property's collection items JsonConverter, type name handling, and reference handling. The DataMemberAttribute can be used as a substitute for JsonPropertyAttribute.JsonIgnoreAttributeExcludes a field or property from serialization.The T:System.NonSerializedAttribute can be used as a substitute for JsonIgnoreAttribute.JsonConverterAttributeThe T:Newtonsoft.Json.JsonConverterAttribute specifies which
T:Newtonsoft.Json.JsonConverter is used to convert an object.The attribute can be placed on a class or a member. When placed on a class, the JsonConverter
specified by the attribute will be the default way of serializing that class. When the attribute is
on a field or property, then the specified JsonConverter will always be used to serialize that value.The priority of which JsonConverter is used is member attribute, then class attribute, and finally
any converters passed to the JsonSerializer.This example shows the JsonConverterAttribute being applied to a property.To apply a JsonConverter to the items in a collection, use either T:Newtonsoft.Json.JsonArrayAttribute,
T:Newtonsoft.Json.JsonDictionaryAttribute or
T:Newtonsoft.Json.JsonPropertyAttribute
and set the ItemConverterType property to the converter type you want to use.JsonExtensionDataAttributeThe T:Newtonsoft.Json.JsonExtensionDataAttribute instructs the
T:Newtonsoft.Json.JsonSerializer to deserialize properties with no matching field or property
on the type into the specified collection. During serialization the values in this collection are written back to the instance's JSON object.All extension data values will be written during serialization, even if a property the same name has already been written.This example shows the JsonExtensionDataAttribute being applied to a field, unmatched JSON properties being added to the field's collection during deserialization.JsonConstructorAttributeThe T:Newtonsoft.Json.JsonConstructorAttribute instructs the
T:Newtonsoft.Json.JsonSerializer to use a specific constructor when deserializing a class. It can be used to create a class using a parameterized constructor instead of the default constructor, or to pick which specific parameterized constructor to use if there are multiple.T:Newtonsoft.Json.JsonObjectAttributeT:Newtonsoft.Json.JsonArrayAttributeT:Newtonsoft.Json.JsonDictionaryAttributeT:Newtonsoft.Json.JsonPropertyAttributeT:Newtonsoft.Json.JsonConverterAttributeT:Newtonsoft.Json.JsonExtensionDataAttributeT:Newtonsoft.Json.JsonConstructorAttribute
================================================
FILE: Doc/SerializationCallbacks.aml
================================================
Json.NET supports serialization callback methods. A callback can be used to manipulate an object before and after its serialization and deserialization by the JsonSerializer.OnSerializingOnSerializedOnDeserializingOnDeserialized
To tell the serializer which methods should be called during the object's
serialization lifecycle, decorate a method with the appropriate attribute
(T:System.Runtime.Serialization.OnSerializingAttribute,
T:System.Runtime.Serialization.OnSerializedAttribute,
T:System.Runtime.Serialization.OnDeserializingAttribute,
T:System.Runtime.Serialization.OnDeserializedAttribute).
ExampleExample object with serialization callback methods:The example object being serialized and deserialized by Json.NET:T:System.Runtime.Serialization.OnSerializingAttributeT:System.Runtime.Serialization.OnSerializedAttributeT:System.Runtime.Serialization.OnDeserializingAttributeT:System.Runtime.Serialization.OnDeserializedAttribute
================================================
FILE: Doc/SerializationErrorHandling.aml
================================================
Json.NET supports error handling during serialization and
deserialization. Error handling lets you catch an error and
choose whether to handle it and continue with serialization or
let the error bubble up and be thrown in your application.Error handling is defined through two methods: the E:Newtonsoft.Json.JsonSerializer.Error event on
JsonSerializer and the T:Newtonsoft.Json.Serialization.OnErrorAttribute.Error EventThe E:Newtonsoft.Json.JsonSerializer.Error
event is an event handler found on T:Newtonsoft.Json.JsonSerializer.
The error event is raised whenever an exception is thrown while serializing
or deserializing JSON. Like all settings found on JsonSerializer, it can also
be set on T:Newtonsoft.Json.JsonSerializerSettings
and passed to the serialization methods on JsonConvert.In this example we are deserializing a JSON array to a collection
of DateTimes. On the JsonSerializerSettings a handler has been assigned
to the Error event which will log the error message and mark the error
as handled.The result of deserializing the JSON is three successfully deserialized
dates and three error messages: one for the badly formatted string ("I am
not a date and will error!"), one for the nested JSON array, and one for the
null value since the list doesn't allow nullable DateTimes. The event
handler has logged these messages and Json.NET has continued on deserializing
the JSON because the errors were marked as handled.One thing to note with error handling in Json.NET is that an
unhandled error will bubble up and raise the event on each of its
parents. For example an unhandled error when serializing a collection of objects
will be raised twice, once against the object and then again on the collection.
This will let you handle an error either where it occurred or on one of its
parents.If you aren't immediately handling an error and only want to
perform an action against it once, then you can check to see whether the
T:Newtonsoft.Json.Serialization.ErrorEventArgs's
CurrentObject is equal to the OriginalObject.
OriginalObject is the object that threw the error and CurrentObject is
the object that the event is being raised against. They will only equal
the first time the event is raised against the OriginalObject.OnErrorAttributeThe T:Newtonsoft.Json.Serialization.OnErrorAttribute
works much like the other .NET serialization attributes
that Json.NET supports. To use it you simply place the
attribute on a method that takes the correct parameters: a
StreamingContext and an ErrorContext. The name of the method doesn't
matter.In this example accessing the Roles property will throw an
exception when no roles have been set. The HandleError method will set
the error when serializing Roles as handled and allow Json.NET to
continue serializing the class.E:Newtonsoft.Json.JsonSerializer.ErrorT:Newtonsoft.Json.Serialization.OnErrorAttribute
================================================
FILE: Doc/SerializationGuide.aml
================================================
The Json.NET serializer can serialize a wide variety of .NET objects. This guide looks at how it works, first at a high level and then in more detail.SummaryAt a high level, the Json.NET serializer will convert primitive .NET values into primitive JSON values,
will convert .NET arrays and collections to JSON arrays, and will convert everything else to JSON objects.Json.NET will throw an error if it encounters incorrect JSON when deserializing a value. For example, if
the serializer encounters a JSON property with an array of values and the type of matching .NET property is not
a collection, then an error will be thrown, and vice-versa.Complex Types
.NETJSONIList, IEnumerable, IList<T>, ArrayArray (properties on the collection will not be serialized)IDictionary, IDictionary<TKey, TValue>Object (dictionary name/values only, properties on the dictionary will not be serialized)Object (more detail below)Object
Primitive Types
.NETJSONStringStringByteSByteUInt16Int16UInt32Int32UInt64Int64IntegerFloatDoubleDecimalFloatEnumInteger (can be the enum value name with T:Newtonsoft.Json.Converters.StringEnumConverter)DateTimeString ()Byte[]String (base 64 encoded)TypeString (type name)GuidStringT:System.ComponentModel.TypeConverter (convertible to String)String
Breakdown of Type SerializationObjects.NET types that don't fall into any other category listed below
(i.e. aren't lists, dictionaries, dynamic, implement ISerializable, etc.)
are serialized as JSON objects. You can also force a type to be serialized as a JSON object by placing the
JsonObjectAttribute on the type.By default a type's properties are serialized in opt-out mode. What that means is that all public fields and properties with
getters are automatically serialized to JSON, and fields and properties that shouldn't be serialized are opted-out by placing
JsonIgnoreAttribute on them. To serialize private members, the JsonPropertyAttribute can be placed on private fields and
properties.Types can also be serialized using opt-in mode. Only properties and fields that have a JsonPropertyAttribute
or DataMemberAttribute on them will be serialized. Opt-in mode for an object is specified by placing the JsonObjectAttribute
or DataContractAttribute on the type.Finally, types can be serialized using a fields mode. All fields, both public and private, are serialized
and properties are ignored. This can be specified by setting MemberSerialization.Fields on a type with the JsonObjectAttribute
or by using the .NET T:System.SerializableAttribute
and setting IgnoreSerializableAttribute on DefaultContractResolver to false.IEnumerable, Lists, and Arrays .NET lists (types that inherit from IEnumerable) and .NET arrays are converted to JSON arrays. Because JSON
arrays only support a range of values and not properties, any additional properties and fields declared on .NET
collections are not serialized. In situations where a type implements IEnumerable but a JSON array is not wanted, then
the JsonObjectAttribute can be placed on the type to force it to be serialized as a JSON object instead.JsonArrayAttribute has options on it to customize the JsonConverter, type name handling, and reference handling
that are applied to collection items.Note that if TypeNameHandling or PreserveReferencesHandling has been enabled for JSON arrays on the serializer,
then JSON arrays are wrapped in a containing object. The object will have the type name/reference properties and a
$values property, which will have the collection data.When deserializing, if a member is typed as the interface IList<T>, then it will be deserialized as a
List<T>.You can read more about serializing collections here: Dictionaries and Hashtables.NET dictionaries (types that inherit from IDictionary) are converted to JSON objects. Note that only the
dictionary name/values will be written to the JSON object when serializing, and properties on the JSON object will
be added to the dictionary's name/values when deserializing. Additional members on the .NET dictionary are ignored
during serialization.When serializing a dictionary, the keys of the dictionary are converted to strings and used as the
JSON object property names. The string written for a key can be customized by either overriding
M:System.Object.ToString for the key type or by implementing a
T:System.ComponentModel.TypeConverter. A TypeConverter will also
support converting a custom string back again when deserializing a dictionary.JsonDictionaryAttribute has options on it to customize the JsonConverter, type name handling, and reference
handling that are applied to collection items.When deserializing, if a member is typed as the interface IDictionary<TKey, TValue> then it will be
deserialized as a Dictionary<TKey, TValue>.You can read more about serializing collections here: Untyped Objects.NET properties on a class that don't specify a type (i.e. they are just object) are serialized as usual. When
untyped properties are deserialized, the serializer has no way of knowing what type to create (unless type name handling
is enabled and the JSON contains the type names).For these untyped properties, the Json.NET serializer will read the JSON into LINQ to JSON objects and set them
to the property. JObject will be created for JSON objects; JArray will be created for JSON arrays, and JValue will be
created for primitive JSON values.DynamicThere are two different usages of dynamic (introduced in .NET 4) in .NET. The first are .NET properties with a
type of dynamic. Dynamic properties behave like properties declared as object: any value can be assigned to it, but
the difference being that properties and methods can be called on a dynamic property without casting. In Json.NET,
dynamic properties are serialized and deserialized exactly the same as untyped objects: because dynamic isn't an actual
type, Json.NET falls back to deserializing the JSON as LINQ to JSON objects.The second usage of dynamic in .NET are by the types that implement
T:System.Dynamic.IDynamicMetaObjectProvider. This interface lets
the implementer create dynamic objects that intercept the property and method calls on an object and use them.
T:System.Dynamic.ExpandoObject
is a good example of a dynamic object.Dynamic objects are serialized as JSON objects. A property is written for every member name returned by
M:System.Dynamic.DynamicMetaObject.GetDynamicMemberNames.
A dynamic object's normal properties aren't serialized by default but can be included by placing the
JsonPropertyAttribute on them.
When deserializing dynamic objects, the serializer first attempts to set JSON property values on a normal .NET
member with the matching name. If no .NET member is found with the property name, then the serializer will call
SetMember on the dynamic object. Because there is no type information for dynamic members on a dynamic object, the
values assigned to them will be LINQ to JSON objects.ISerializableTypes that implement T:System.Runtime.Serialization.ISerializable and
are marked with T:System.SerializableAttribute are serialized as JSON objects. When serializing, only the values returned from
ISerializable.GetObjectData are used; members on the type are ignored. When deserializing, the constructor with a
SerializationInfo and StreamingContext is called, passing the JSON object's values.In situations where this behavior is not wanted, the JsonObjectAttribute can be placed on a .NET type that
implements ISerializable to force it to be serialized as a normal JSON object.LINQ to JSONLINQ to JSON types (e.g. JObject and JArray) are automatically serialized and deserialized to their equivalent JSON
when encountered by the Json.NET serializer.JsonConverterSerialization of values that are convertible by a T:Newtonsoft.Json.JsonConverter
(i.e. CanConvert returns true for its type) is
completely overridden by the JsonConverter. The test to see whether a value can be converted by the JsonSerializer takes
precedence over all other tests.JsonConverters can be defined and specified in a number of places: in an attribute on a member, in an attribute
on a class, and added to the JsonSerializer's converters collection. The priority of which JsonConverter is used is the
JsonConverter defined by attribute on a member, then the JsonConverter defined by an attribute on a class, and finally
any converters passed to the JsonSerializer.Because a JsonConverter creates a new value, a converter will not work with readonly properties because there is no way to assign the new
value to the property. Either change the property to have a public setter or place a JsonPropertyAttribute or DataMemberAttribute on the property.T:Newtonsoft.Json.JsonSerializerT:Newtonsoft.Json.JsonSerializerSettings
================================================
FILE: Doc/SerializationSettings.aml
================================================
JsonSerializer has a number of properties on it to customize how it serializes JSON. These can also be used
with the methods on JsonConvert via the T:Newtonsoft.Json.JsonSerializerSettings overloads.DateFormatHandlingT:Newtonsoft.Json.DateFormatHandling controls how dates are serialized.
MemberDescriptionIsoDateFormatBy default Json.NET writes dates in the ISO 8601 format, e.g. "2012-03-21T05:40Z".MicrosoftDateFormatDates are written in the Microsoft JSON format, e.g. "\/Date(1198908717056)\/".
MissingMemberHandlingT:Newtonsoft.Json.MissingMemberHandling controls how missing members, e.g. JSON contains a property that isn't a member on the object, are handled during deserialization.
MemberDescriptionIgnoreBy default Json.NET ignores JSON if there is no field or property for its value to be set to during deserialization.ErrorJson.NET errors when there is a missing member during deserialization.
ReferenceLoopHandlingT:Newtonsoft.Json.ReferenceLoopHandling controls how circular referencing objects,
e.g. a Person object referencing itself via a Manager property, are serialized.The M:System.Object.Equals(System.Object) method is used to test whether an object is in a circular reference.
By default Object.Equals(Object) will test whether the references are equal for reference types and private and public values
are equal for value types. Classes and structs can override this method.
MemberDescriptionErrorBy default Json.NET will error if a reference loop is encountered (otherwise the serializer will get into an infinite loop).IgnoreJson.NET will ignore objects in reference loops and not serialize them. The first time an object is encountered it will be serialized as usual but if the object is encountered as a child object of itself the serializer will skip serializing it.SerializeThis option forces Json.NET to serialize objects in reference loops. This is useful if objects are nested but not indefinitely.
ReferenceLoopHandling can be used as an argument when calling the serializer, it can be set on an object's properties or
a collection's items using P:Newtonsoft.Json.JsonContainerAttribute.ItemReferenceLoopHandling,
customized on a property with P:Newtonsoft.Json.JsonPropertyAttribute.ReferenceLoopHandling
or a property's object properties or collection items using
P:Newtonsoft.Json.JsonPropertyAttribute.ItemReferenceLoopHandling.NullValueHandlingT:Newtonsoft.Json.NullValueHandling controls how null values on .NET objects are handled during serialization and how null values in JSON are handled during deserialization.
MemberDescriptionIncludeBy default Json.NET writes null values to JSON when serializing and sets null values to fields/properties when deserializing.IgnoreJson.NET will skip writing JSON properties if the .NET value is null when serializing and will skip setting fields/properties if the JSON property is null when deserializing.
NullValueHandling can also be customized on individual properties with JsonPropertyAttribute.DefaultValueHandlingT:Newtonsoft.Json.DefaultValueHandling controls how Json.NET uses default values set using the .NET T:System.ComponentModel.DefaultValueAttribute when serializing and deserializing.
MemberDescriptionIncludeBy default Json.NET will write a field/property value to JSON when serializing if the value is the same as the field/property's default value.
The Json.NET deserializer will continue setting a field/property if the JSON value is the same as the default value.IgnoreJson.NET will skip writing a field/property value to JSON if the value is the same as the field/property's default value, or the custom
value specified in T:System.ComponentModel.DefaultValueAttribute if the attribute is present. The Json.NET deserializer
will skip setting a .NET object's field/property if the JSON value is the same as the default value.
DefaultValueHandling can also be customized on individual properties with JsonPropertyAttribute.ObjectCreationHandlingT:Newtonsoft.Json.ObjectCreationHandling controls how objects are created and deserialized to during deserialization.
MemberDescriptionAutoBy default Json.NET will attempt to set JSON values onto existing objects and add JSON values to existing collections during deserialization. ReuseSame behaviour as auto.ReplaceJson.NET will always recreate objects and collections before setting values to them during deserialization.
ObjectCreationHandling can also be customized on individual properties with JsonPropertyAttribute.TypeNameHandlingT:Newtonsoft.Json.TypeNameHandling should be used with caution when your application deserializes JSON from an external source.
Incoming types should be validated with a custom T:Newtonsoft.Json.Serialization.ISerializationBinder when deserializing with a value other than TypeNameHandling.None.
T:Newtonsoft.Json.TypeNameHandling controls whether Json.NET includes .NET type names
during serialization with a $type property and reads .NET type names from that property to determine what type to create during
deserialization.
Metadata properties like $type must be located at the beginning of a JSON object to be successfully detected during deserialization. If you can't control
the order of properties in your JSON object then T:Newtonsoft.Json.MetadataPropertyHandling can be used to remove this restriction.
The value of the $type property can be customized and validated by creating your own
T:Newtonsoft.Json.Serialization.ISerializationBinder.
MemberDescriptionNoneBy default Json.NET does not read or write type names during deserialization.ObjectsJson.NET will write and use type names for objects but not collections.ArraysJson.NET will write and use type names for collections but not objects.AutoJson.NET will check whether an object/collection matches its declared property and writes the type name if they do not match, e.g. a property with a type of Mammal has a derived instance of Dog assigned. Auto will ensure that type information isn't lost when serializing/deserializing automatically without having to write type names for every object.AllJson.NET will write and use type names for objects and collections.
TypeNameHandling can be used as an argument when calling the serializer, it can be set on an object's properties or
a collection's items using P:Newtonsoft.Json.JsonContainerAttribute.ItemTypeNameHandling,
customized on a property with P:Newtonsoft.Json.JsonPropertyAttribute.TypeNameHandling
or a property's object properties or collection items using
P:Newtonsoft.Json.JsonPropertyAttribute.ItemTypeNameHandling.TypeNameAssemblyFormatT:System.Runtime.Serialization.Formatters.FormatterAssemblyStyle controls how type names are written during serialization.
MemberDescriptionSimpleBy default Json.NET writes the partial assembly name with the type, e.g. System.Data.DataSet, System.Data. Note that Silverlight and Windows Phone are not able to use this format.FullJson.NET will write the full assembly name, including version number, culture and public key token.
Read more about the valid values at T:System.Runtime.Serialization.Formatters.FormatterAssemblyStyle.SerializationBinderThe T:Newtonsoft.Json.Serialization.ISerializationBinder is used to resolve .NET types to type names during serialization and type names to .NET types during deserialization.
If TypeNameHandling is enabled then it is strongly recommended that a custom T:Newtonsoft.Json.Serialization.ISerializationBinder is used to validate incoming type names for security reasons.MetadataPropertyHandlingT:Newtonsoft.Json.MetadataPropertyHandling controls how metadata properties like $type and $id are read during deserialization.
For performance reasons by default the JsonSerializer assumes that any metadata properties are located at the beginning of a JSON object.
If you are unable to guarantee the order of properties in JSON you are deserializing then MetadataPropertyHandling.ReadAhead removes this
restriction at the cost of some performance.
MemberDescriptionDefaultBy default Json.NET will only read metadata properties that are at the beginning of a JSON object.ReadAheadJson.NET will look for metadata properties located anywhere in a JSON object.IgnoreJson.NET will ignore metadata properties.
ConstructorHandlingT:Newtonsoft.Json.ConstructorHandling controls how constructors are used when initializing objects during deserialization.
MemberDescriptionDefaultBy default Json.NET will first look for a constructor marked with the JsonConstructorAttribute, then look for a public default constructor
(a constructor that doesn't take any arguments), then check if the class has a single public constructor with arguments and finally check for a
non-public default constructor. If the class has multiple public constructors with arguments an error will be thrown. This can be fixed by
marking one of the constructors with the JsonConstructorAttribute.AllowNonPublicDefaultConstructorJson.NET will use a classes private default constructor before constructors with arguments if available.
ConvertersThis is the collection of JsonConverters that will be used during serialization and deserialization.A T:Newtonsoft.Json.JsonConverter allows JSON to be manually written during serialization and read during deserialization.
This is useful for particularly complex JSON structures or for when you want to change how a type is serialized.When a JsonConverter has been added to a JsonSerializer it will be checked for every value that is being serialized/deserialized
using its CanConvert to see if it should be used. If CanConvert returns true then the JsonConverter will be used to read or write
the JSON for that value. Note that while a JsonConverter gives you complete control over that values JSON, many Json.NET serialization
features are no longer available like type name and reference handling.JsonConverters can be used as an argument when calling the serializer, it can be set on an object or property
using T:Newtonsoft.Json.JsonConverterAttribute, it be set on an object's properties or
a collection's items using P:Newtonsoft.Json.JsonContainerAttribute.ItemConverterType,
or a property's object properties or collection items using
P:Newtonsoft.Json.JsonPropertyAttribute.ItemConverterType.To create your own custom converter inherit from the JsonConverter class. Read more about the built-in JsonConverters below:T:Newtonsoft.Json.Converters.StringEnumConverterContractResolverInternally for every .NET type the JsonSerializer will create a contract of how the type should be serialized and deserialized,
based on type metadata and attributes applied to the class. Specifying a custom T:Newtonsoft.Json.Serialization.IContractResolver
allows the creation of contracts to be customized.Read more about Contract Resolvers here: TraceWriterThe Json.NET serializer supports logging and debugging using the
T:Newtonsoft.Json.Serialization.ITraceWriter interface.
By assigning a trace writer you can debug what happens inside the Json.NET serializer when serializing and deserializing JSON.Read more about TraceWriters here: ErrorThe E:Newtonsoft.Json.JsonSerializer.Error event can catch errors during serialization and either handle the event and continue with
serialization or let the error bubble up and be thrown to the application.Read more about error handling here: T:Newtonsoft.Json.JsonSerializerT:Newtonsoft.Json.JsonSerializerSettingsT:Newtonsoft.Json.JsonConverterT:System.Runtime.Serialization.SerializationBinder
================================================
FILE: Doc/SerializationTracing.aml
================================================
The Json.NET serializer supports logging and debugging using the
T:Newtonsoft.Json.Serialization.ITraceWriter interface.
By assigning a trace writer you can capture serialization messages and errors and debug what happens inside the
Json.NET serializer when serializing and deserializing JSON.ITraceWriterA trace writer can be assigned using properties on JsonSerializerSettings or JsonSerializer.Json.NET has two implementations of ITraceWriter: T:Newtonsoft.Json.Serialization.MemoryTraceWriter,
which keeps messages in memory for simple debugging, like the example
above, and T:Newtonsoft.Json.Serialization.DiagnosticsTraceWriter, which writes messages to any
System.Diagnostics.TraceListeners your application is using.Custom ITraceWriterTo write messages using your existing logging framework, just implement a custom version of ITraceWriter.T:Newtonsoft.Json.JsonSerializerT:Newtonsoft.Json.Serialization.ITraceWriterT:Newtonsoft.Json.Serialization.MemoryTraceWriterT:Newtonsoft.Json.Serialization.DiagnosticsTraceWriter
================================================
FILE: Doc/SerializingCollections.aml
================================================
Json.NET has excellent support for serializing and deserializing
collections of objects.Serializing CollectionsTo serialize a collection - a generic list, array, dictionary, or
your own custom collection - simply call the serializer with the object
you want to get JSON for. Json.NET will serialize the collection and all
of the values it contains.Deserializing CollectionsTo deserialize JSON into a .NET collection, just specify the collection
type you want to deserialize to. Json.NET supports a wide range of collection
types.Deserializing DictionariesUsing Json.NET you can also deserialize a JSON object into a .NET
generic dictionary. The JSON object's property names and values will be
added to the dictionary.T:Newtonsoft.Json.JsonConvertT:Newtonsoft.Json.JsonSerializer
================================================
FILE: Doc/SerializingJSON.aml
================================================
The quickest method of converting between JSON text and a .NET object is using the
T:Newtonsoft.Json.JsonSerializer.
The JsonSerializer converts .NET objects into their JSON equivalent and back again by mapping the .NET object property names to the JSON property names
and copies the values for you.JsonConvertFor simple scenarios where you want to convert to and from a JSON string, the
Overload:Newtonsoft.Json.JsonConvert.SerializeObject and
Overload:Newtonsoft.Json.JsonConvert.DeserializeObject
methods on JsonConvert provide an easy-to-use wrapper over JsonSerializer.
SerializeObject and DeserializeObject both have overloads that take a T:Newtonsoft.Json.JsonSerializerSettings object.
JsonSerializerSettings lets you use many of the JsonSerializer settings listed below while still using the simple serialization methods.
JsonSerializerFor more control over how an object is serialized, the T:Newtonsoft.Json.JsonSerializer can be used directly.
The JsonSerializer is able to read and write JSON text directly to a stream via T:Newtonsoft.Json.JsonTextReader
and T:Newtonsoft.Json.JsonTextWriter.
Other kinds of JsonWriters can also be used, such as
T:Newtonsoft.Json.Linq.JTokenReader/T:Newtonsoft.Json.Linq.JTokenWriter,
to convert your object to and from LINQ to JSON objects, or
T:Newtonsoft.Json.Bson.BsonReader/T:Newtonsoft.Json.Bson.BsonWriter, to convert to and from BSON.JsonSerializer has a number of properties on it to customize how it serializes JSON. These can also be used with the methods on JsonConvert via the JsonSerializerSettings overloads.You can read more about the available JsonSerializer settings here: T:Newtonsoft.Json.JsonConvertT:Newtonsoft.Json.JsonSerializerT:Newtonsoft.Json.JsonSerializerSettings
================================================
FILE: Doc/SerializingJSONFragments.aml
================================================
Often when working with large JSON documents you're only interested in a small
fragment of information. This scenario can be annoying when you want to deserialize
that JSON fragment into .NET objects because you have to define .NET classes for the
entire JSON result.With Json.NET it is easy to get around this problem. Using LINQ to JSON you
can extract the pieces of JSON you want to deserialize before passing them to the
Json.NET serializer.T:Newtonsoft.Json.JsonReaderT:Newtonsoft.Json.JsonWriterT:Newtonsoft.Json.Linq.JTokenReaderT:Newtonsoft.Json.Linq.JTokenWriterT:Newtonsoft.Json.Bson.BsonReaderT:Newtonsoft.Json.Bson.BsonWriter
================================================
FILE: Doc/doc.content
================================================
================================================
FILE: Doc/doc.shfbproj
================================================
DebugAnyCPU2.0{fd19f68e-72c8-4576-9775-b4480b0db686}2017.9.26.0DocumentationDocumentationDocumentation..\Working\Documentation\DocumentationSummary, Parameter, Returns, AutoDocumentCtors, Namespace, TypeParameter, AutoDocumentDisposeInheritedMembers, InheritedFrameworkMembers, Protected, SealedProtected, ProtectedInternalAsProtected, EditorBrowsableNever, NonBrowsableWebsite.NET Framework 4.5Json.NET DocumentationVS2013MemberName..\Working\Src\Newtonsoft.Json\bin\Release\Net45The <b>Newtonsoft.Json</b> namespace provides classes that are used to implement the core services of the framework.The <b>Newtonsoft.Json.Converters</b> namespace provides classes that inherit from <a href="T_Newtonsoft_Json_JsonConverter.htm">JsonConverter</a>.The <b>Newtonsoft.Json.Linq</b> namespace provides classes that are used to implement LINQ to JSON.The <b>Newtonsoft.Json.Linq.ComponentModel</b> namespace provides classes for LINQ to JSON databinding.<para>The <b>Newtonsoft.Json.Schema</b> namespace provides classes that are used to implement JSON schema.</para>
<para><b>Obsolete.</b> JSON Schema validation has been moved to its own package. See <a href="https://www.newtonsoft.com/jsonschema">https://www.newtonsoft.com/jsonschema</a> for more details.</para>The <b>Newtonsoft.Json.Linq</b> namespace provides classes that are used when serializing and deserializing JSON.The <b>Newtonsoft.Json.Linq</b> namespace provides classes that are used to implement BSON.TrueAPI Reference{@HelpFormatOutputPaths}FalseOnlyWarningsAndErrorsTrueFalseFalseTrueC#BlankFalseen-USAboveNamespaces2False<%3ba href="%3b../../"%3b>%3bJson.NET Home<%3b/a>%3bticktickcrosscrossperformanceperformancelogologo
================================================
FILE: Doc/license.txt
================================================
Copyright (c) 2007 James Newton-King
Permission is hereby granted, free of charge, to any person obtaining a copy of this
software and associated documentation files (the "Software"), to deal in the Software
without restriction, including without limitation the rights to use, copy, modify,
merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice shall be included in all copies
or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
================================================
FILE: Doc/readme.txt
================================================
Json.NET
https://www.newtonsoft.com/json
https://github.com/JamesNK/Newtonsoft.Json
Description:
Json.NET is a popular high-performance JSON framework for .NET
-Flexible JSON serializer for converting between .NET objects and JSON
-LINQ to JSON for manually reading and writing JSON
-High performance, faster than .NET's built-in JSON serializers
-Write indented, easy to read JSON
-Convert JSON to and from XML
-Supports .NET 2, .NET 3.5, .NET 4, .NET 4.5, Silverlight, Windows Phone, Windows 8 Store and .NET Core
Documentation:
https://www.newtonsoft.com/json/help/
Versions:
Json.NET has different libraries for the various .NET Framework versions.
-net45:
.NET 4.5+
-net40:
.NET 4.0
-net35:
.NET 3.5
-net20:
.NET 2.0, Unity
-portable-net45+win8+wpa81+wp8:
.NET 4.5, Windows Phone 8, Windows 8 Store
-portable-net40+win8+wpa81+wp8+sl5:
.NET 4.0, Windows Phone 8, Windows 8 Store, Silverlight 5, MonoTouch, MonoDroid
-netstandard1.0:
.NET Standard 1.0
-netstandard1.3:
.NET Standard 1.3
-netstandard2.0:
.NET Standard 2.0
Notes:
For a Compact Framework 3.5 and Silverlight 3.0 builds download Json.NET 3.5
For a Silverlight 4.0 and Windows Phone 7 builds download Json.NET 5
================================================
FILE: ISSUE_TEMPLATE.md
================================================
### Source/destination types
```csharp
// Put the types you are serializing or deserializing here
```
### Source/destination JSON
```javascript
{"message":"Place your serialized or deserialized JSON here"}
```
### Expected behavior
### Actual behavior
### Steps to reproduce
```csharp
// Your calls to Newtonsoft.Json here
```
================================================
FILE: LICENSE.md
================================================
The MIT License (MIT)
Copyright (c) 2007 James Newton-King
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
================================================
FILE: README.md
================================================
#  Json.NET
[](https://www.nuget.org/packages/Newtonsoft.Json/)
[](https://dev.azure.com/jamesnk/Public/_build/latest?definitionId=8)
- [Homepage](https://www.newtonsoft.com/json)
- [Documentation](https://www.newtonsoft.com/json/help)
- [NuGet Package](https://www.nuget.org/packages/Newtonsoft.Json)
- [Release Notes](https://github.com/JamesNK/Newtonsoft.Json/releases)
- [Contributing Guidelines](CONTRIBUTING.md)
- [License](LICENSE.md)
- [Stack Overflow](https://stackoverflow.com/questions/tagged/json.net)
================================================
FILE: Src/Directory.Build.props
================================================
4.6.20.10.104.2.38.0.04.3.01.0.016.3.04.8.13.11.03.13.04.4.01.4.04.3.04.3.04.3.04.3.04.3.04.3.04.4.02.3.12.3.1
================================================
FILE: Src/Newtonsoft.Json/Bson/BsonBinaryType.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
#nullable disable
namespace Newtonsoft.Json.Bson
{
internal enum BsonBinaryType : byte
{
Binary = 0x00,
Function = 0x01,
[Obsolete("This type has been deprecated in the BSON specification. Use Binary instead.")]
BinaryOld = 0x02,
[Obsolete("This type has been deprecated in the BSON specification. Use Uuid instead.")]
UuidOld = 0x03,
Uuid = 0x04,
Md5 = 0x05,
UserDefined = 0x80
}
}
================================================
FILE: Src/Newtonsoft.Json/Bson/BsonBinaryWriter.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
using System.Globalization;
using System.IO;
using System.Text;
using Newtonsoft.Json.Utilities;
#nullable disable
namespace Newtonsoft.Json.Bson
{
internal class BsonBinaryWriter
{
private static readonly Encoding Encoding = new UTF8Encoding(false);
private readonly BinaryWriter _writer;
private byte[] _largeByteBuffer;
public DateTimeKind DateTimeKindHandling { get; set; }
public BsonBinaryWriter(BinaryWriter writer)
{
DateTimeKindHandling = DateTimeKind.Utc;
_writer = writer;
}
public void Flush()
{
_writer.Flush();
}
public void Close()
{
#if HAVE_STREAM_READER_WRITER_CLOSE
_writer.Close();
#else
_writer.Dispose();
#endif
}
public void WriteToken(BsonToken t)
{
CalculateSize(t);
WriteTokenInternal(t);
}
private void WriteTokenInternal(BsonToken t)
{
switch (t.Type)
{
case BsonType.Object:
{
BsonObject value = (BsonObject)t;
_writer.Write(value.CalculatedSize);
foreach (BsonProperty property in value)
{
_writer.Write((sbyte)property.Value.Type);
WriteString((string)property.Name.Value, property.Name.ByteCount, null);
WriteTokenInternal(property.Value);
}
_writer.Write((byte)0);
}
break;
case BsonType.Array:
{
BsonArray value = (BsonArray)t;
_writer.Write(value.CalculatedSize);
ulong index = 0;
foreach (BsonToken c in value)
{
_writer.Write((sbyte)c.Type);
WriteString(index.ToString(CultureInfo.InvariantCulture), MathUtils.IntLength(index), null);
WriteTokenInternal(c);
index++;
}
_writer.Write((byte)0);
}
break;
case BsonType.Integer:
{
BsonValue value = (BsonValue)t;
_writer.Write(Convert.ToInt32(value.Value, CultureInfo.InvariantCulture));
}
break;
case BsonType.Long:
{
BsonValue value = (BsonValue)t;
_writer.Write(Convert.ToInt64(value.Value, CultureInfo.InvariantCulture));
}
break;
case BsonType.Number:
{
BsonValue value = (BsonValue)t;
_writer.Write(Convert.ToDouble(value.Value, CultureInfo.InvariantCulture));
}
break;
case BsonType.String:
{
BsonString value = (BsonString)t;
WriteString((string)value.Value, value.ByteCount, value.CalculatedSize - 4);
}
break;
case BsonType.Boolean:
_writer.Write(t == BsonBoolean.True);
break;
case BsonType.Null:
case BsonType.Undefined:
break;
case BsonType.Date:
{
BsonValue value = (BsonValue)t;
long ticks = 0;
if (value.Value is DateTime dateTime)
{
if (DateTimeKindHandling == DateTimeKind.Utc)
{
dateTime = dateTime.ToUniversalTime();
}
else if (DateTimeKindHandling == DateTimeKind.Local)
{
dateTime = dateTime.ToLocalTime();
}
ticks = DateTimeUtils.ConvertDateTimeToJavaScriptTicks(dateTime, false);
}
#if HAVE_DATE_TIME_OFFSET
else
{
DateTimeOffset dateTimeOffset = (DateTimeOffset)value.Value;
ticks = DateTimeUtils.ConvertDateTimeToJavaScriptTicks(dateTimeOffset.UtcDateTime, dateTimeOffset.Offset);
}
#endif
_writer.Write(ticks);
}
break;
case BsonType.Binary:
{
BsonBinary value = (BsonBinary)t;
byte[] data = (byte[])value.Value;
_writer.Write(data.Length);
_writer.Write((byte)value.BinaryType);
_writer.Write(data);
}
break;
case BsonType.Oid:
{
BsonValue value = (BsonValue)t;
byte[] data = (byte[])value.Value;
_writer.Write(data);
}
break;
case BsonType.Regex:
{
BsonRegex value = (BsonRegex)t;
WriteString((string)value.Pattern.Value, value.Pattern.ByteCount, null);
WriteString((string)value.Options.Value, value.Options.ByteCount, null);
}
break;
default:
throw new ArgumentOutOfRangeException(nameof(t), "Unexpected token when writing BSON: {0}".FormatWith(CultureInfo.InvariantCulture, t.Type));
}
}
private void WriteString(string s, int byteCount, int? calculatedlengthPrefix)
{
if (calculatedlengthPrefix != null)
{
_writer.Write(calculatedlengthPrefix.GetValueOrDefault());
}
WriteUtf8Bytes(s, byteCount);
_writer.Write((byte)0);
}
public void WriteUtf8Bytes(string s, int byteCount)
{
if (s != null)
{
if (byteCount <= 256)
{
if (_largeByteBuffer == null)
{
_largeByteBuffer = new byte[256];
}
Encoding.GetBytes(s, 0, s.Length, _largeByteBuffer, 0);
_writer.Write(_largeByteBuffer, 0, byteCount);
}
else
{
byte[] bytes = Encoding.GetBytes(s);
_writer.Write(bytes);
}
}
}
private int CalculateSize(int stringByteCount)
{
return stringByteCount + 1;
}
private int CalculateSizeWithLength(int stringByteCount, bool includeSize)
{
int baseSize = (includeSize)
? 5 // size bytes + terminator
: 1; // terminator
return baseSize + stringByteCount;
}
private int CalculateSize(BsonToken t)
{
switch (t.Type)
{
case BsonType.Object:
{
BsonObject value = (BsonObject)t;
int bases = 4;
foreach (BsonProperty p in value)
{
int size = 1;
size += CalculateSize(p.Name);
size += CalculateSize(p.Value);
bases += size;
}
bases += 1;
value.CalculatedSize = bases;
return bases;
}
case BsonType.Array:
{
BsonArray value = (BsonArray)t;
int size = 4;
ulong index = 0;
foreach (BsonToken c in value)
{
size += 1;
size += CalculateSize(MathUtils.IntLength(index));
size += CalculateSize(c);
index++;
}
size += 1;
value.CalculatedSize = size;
return value.CalculatedSize;
}
case BsonType.Integer:
return 4;
case BsonType.Long:
return 8;
case BsonType.Number:
return 8;
case BsonType.String:
{
BsonString value = (BsonString)t;
string s = (string)value.Value;
value.ByteCount = (s != null) ? Encoding.GetByteCount(s) : 0;
value.CalculatedSize = CalculateSizeWithLength(value.ByteCount, value.IncludeLength);
return value.CalculatedSize;
}
case BsonType.Boolean:
return 1;
case BsonType.Null:
case BsonType.Undefined:
return 0;
case BsonType.Date:
return 8;
case BsonType.Binary:
{
BsonBinary value = (BsonBinary)t;
byte[] data = (byte[])value.Value;
value.CalculatedSize = 4 + 1 + data.Length;
return value.CalculatedSize;
}
case BsonType.Oid:
return 12;
case BsonType.Regex:
{
BsonRegex value = (BsonRegex)t;
int size = 0;
size += CalculateSize(value.Pattern);
size += CalculateSize(value.Options);
value.CalculatedSize = size;
return value.CalculatedSize;
}
default:
throw new ArgumentOutOfRangeException(nameof(t), "Unexpected token when writing BSON: {0}".FormatWith(CultureInfo.InvariantCulture, t.Type));
}
}
}
}
================================================
FILE: Src/Newtonsoft.Json/Bson/BsonObjectId.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
using Newtonsoft.Json.Utilities;
#nullable disable
namespace Newtonsoft.Json.Bson
{
///
/// Represents a BSON Oid (object id).
///
[Obsolete("BSON reading and writing has been moved to its own package. See https://www.nuget.org/packages/Newtonsoft.Json.Bson for more details.")]
public class BsonObjectId
{
///
/// Gets or sets the value of the Oid.
///
/// The value of the Oid.
public byte[] Value { get; }
///
/// Initializes a new instance of the class.
///
/// The Oid value.
public BsonObjectId(byte[] value)
{
ValidationUtils.ArgumentNotNull(value, nameof(value));
if (value.Length != 12)
{
throw new ArgumentException("An ObjectId must be 12 bytes", nameof(value));
}
Value = value;
}
}
}
================================================
FILE: Src/Newtonsoft.Json/Bson/BsonReader.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Text;
using System.IO;
using Newtonsoft.Json.Serialization;
using Newtonsoft.Json.Utilities;
using Newtonsoft.Json.Linq;
#nullable disable
namespace Newtonsoft.Json.Bson
{
///
/// Represents a reader that provides fast, non-cached, forward-only access to serialized BSON data.
///
[Obsolete("BSON reading and writing has been moved to its own package. See https://www.nuget.org/packages/Newtonsoft.Json.Bson for more details.")]
public class BsonReader : JsonReader
{
private const int MaxCharBytesSize = 128;
private static readonly byte[] SeqRange1 = new byte[] { 0, 127 }; // range of 1-byte sequence
private static readonly byte[] SeqRange2 = new byte[] { 194, 223 }; // range of 2-byte sequence
private static readonly byte[] SeqRange3 = new byte[] { 224, 239 }; // range of 3-byte sequence
private static readonly byte[] SeqRange4 = new byte[] { 240, 244 }; // range of 4-byte sequence
private readonly BinaryReader _reader;
private readonly List _stack;
private byte[] _byteBuffer;
private char[] _charBuffer;
private BsonType _currentElementType;
private BsonReaderState _bsonReaderState;
private ContainerContext _currentContext;
private bool _readRootValueAsArray;
private bool _jsonNet35BinaryCompatibility;
private DateTimeKind _dateTimeKindHandling;
private enum BsonReaderState
{
Normal = 0,
ReferenceStart = 1,
ReferenceRef = 2,
ReferenceId = 3,
CodeWScopeStart = 4,
CodeWScopeCode = 5,
CodeWScopeScope = 6,
CodeWScopeScopeObject = 7,
CodeWScopeScopeEnd = 8
}
private class ContainerContext
{
public readonly BsonType Type;
public int Length;
public int Position;
public ContainerContext(BsonType type)
{
Type = type;
}
}
///
/// Gets or sets a value indicating whether binary data reading should be compatible with incorrect Json.NET 3.5 written binary.
///
///
/// true if binary data reading will be compatible with incorrect Json.NET 3.5 written binary; otherwise, false.
///
[Obsolete("JsonNet35BinaryCompatibility will be removed in a future version of Json.NET.")]
public bool JsonNet35BinaryCompatibility
{
get => _jsonNet35BinaryCompatibility;
set => _jsonNet35BinaryCompatibility = value;
}
///
/// Gets or sets a value indicating whether the root object will be read as a JSON array.
///
///
/// true if the root object will be read as a JSON array; otherwise, false.
///
public bool ReadRootValueAsArray
{
get => _readRootValueAsArray;
set => _readRootValueAsArray = value;
}
///
/// Gets or sets the used when reading values from BSON.
///
/// The used when reading values from BSON.
public DateTimeKind DateTimeKindHandling
{
get => _dateTimeKindHandling;
set => _dateTimeKindHandling = value;
}
///
/// Initializes a new instance of the class.
///
/// The containing the BSON data to read.
public BsonReader(Stream stream)
: this(stream, false, DateTimeKind.Local)
{
}
///
/// Initializes a new instance of the class.
///
/// The containing the BSON data to read.
public BsonReader(BinaryReader reader)
: this(reader, false, DateTimeKind.Local)
{
}
///
/// Initializes a new instance of the class.
///
/// The containing the BSON data to read.
/// if set to true the root object will be read as a JSON array.
/// The used when reading values from BSON.
public BsonReader(Stream stream, bool readRootValueAsArray, DateTimeKind dateTimeKindHandling)
{
ValidationUtils.ArgumentNotNull(stream, nameof(stream));
_reader = new BinaryReader(stream);
_stack = new List();
_readRootValueAsArray = readRootValueAsArray;
_dateTimeKindHandling = dateTimeKindHandling;
}
///
/// Initializes a new instance of the class.
///
/// The containing the BSON data to read.
/// if set to true the root object will be read as a JSON array.
/// The used when reading values from BSON.
public BsonReader(BinaryReader reader, bool readRootValueAsArray, DateTimeKind dateTimeKindHandling)
{
ValidationUtils.ArgumentNotNull(reader, nameof(reader));
_reader = reader;
_stack = new List();
_readRootValueAsArray = readRootValueAsArray;
_dateTimeKindHandling = dateTimeKindHandling;
}
private string ReadElement()
{
_currentElementType = ReadType();
string elementName = ReadString();
return elementName;
}
///
/// Reads the next JSON token from the underlying .
///
///
/// true if the next token was read successfully; false if there are no more tokens to read.
///
public override bool Read()
{
try
{
bool success;
switch (_bsonReaderState)
{
case BsonReaderState.Normal:
success = ReadNormal();
break;
case BsonReaderState.ReferenceStart:
case BsonReaderState.ReferenceRef:
case BsonReaderState.ReferenceId:
success = ReadReference();
break;
case BsonReaderState.CodeWScopeStart:
case BsonReaderState.CodeWScopeCode:
case BsonReaderState.CodeWScopeScope:
case BsonReaderState.CodeWScopeScopeObject:
case BsonReaderState.CodeWScopeScopeEnd:
success = ReadCodeWScope();
break;
default:
throw JsonReaderException.Create(this, "Unexpected state: {0}".FormatWith(CultureInfo.InvariantCulture, _bsonReaderState));
}
if (!success)
{
SetToken(JsonToken.None);
return false;
}
return true;
}
catch (EndOfStreamException)
{
SetToken(JsonToken.None);
return false;
}
}
///
/// Changes the reader's state to .
/// If is set to true, the underlying is also closed.
///
public override void Close()
{
base.Close();
if (CloseInput)
{
#if HAVE_STREAM_READER_WRITER_CLOSE
_reader?.Close();
#else
_reader?.Dispose();
#endif
}
}
private bool ReadCodeWScope()
{
switch (_bsonReaderState)
{
case BsonReaderState.CodeWScopeStart:
SetToken(JsonToken.PropertyName, "$code");
_bsonReaderState = BsonReaderState.CodeWScopeCode;
return true;
case BsonReaderState.CodeWScopeCode:
// total CodeWScope size - not used
ReadInt32();
SetToken(JsonToken.String, ReadLengthString());
_bsonReaderState = BsonReaderState.CodeWScopeScope;
return true;
case BsonReaderState.CodeWScopeScope:
if (CurrentState == State.PostValue)
{
SetToken(JsonToken.PropertyName, "$scope");
return true;
}
else
{
SetToken(JsonToken.StartObject);
_bsonReaderState = BsonReaderState.CodeWScopeScopeObject;
ContainerContext newContext = new ContainerContext(BsonType.Object);
PushContext(newContext);
newContext.Length = ReadInt32();
return true;
}
case BsonReaderState.CodeWScopeScopeObject:
bool result = ReadNormal();
if (result && TokenType == JsonToken.EndObject)
{
_bsonReaderState = BsonReaderState.CodeWScopeScopeEnd;
}
return result;
case BsonReaderState.CodeWScopeScopeEnd:
SetToken(JsonToken.EndObject);
_bsonReaderState = BsonReaderState.Normal;
return true;
default:
throw new ArgumentOutOfRangeException();
}
}
private bool ReadReference()
{
switch (CurrentState)
{
case State.ObjectStart:
{
SetToken(JsonToken.PropertyName, JsonTypeReflector.RefPropertyName);
_bsonReaderState = BsonReaderState.ReferenceRef;
return true;
}
case State.Property:
{
if (_bsonReaderState == BsonReaderState.ReferenceRef)
{
SetToken(JsonToken.String, ReadLengthString());
return true;
}
else if (_bsonReaderState == BsonReaderState.ReferenceId)
{
SetToken(JsonToken.Bytes, ReadBytes(12));
return true;
}
else
{
throw JsonReaderException.Create(this, "Unexpected state when reading BSON reference: " + _bsonReaderState);
}
}
case State.PostValue:
{
if (_bsonReaderState == BsonReaderState.ReferenceRef)
{
SetToken(JsonToken.PropertyName, JsonTypeReflector.IdPropertyName);
_bsonReaderState = BsonReaderState.ReferenceId;
return true;
}
else if (_bsonReaderState == BsonReaderState.ReferenceId)
{
SetToken(JsonToken.EndObject);
_bsonReaderState = BsonReaderState.Normal;
return true;
}
else
{
throw JsonReaderException.Create(this, "Unexpected state when reading BSON reference: " + _bsonReaderState);
}
}
default:
throw JsonReaderException.Create(this, "Unexpected state when reading BSON reference: " + CurrentState);
}
}
private bool ReadNormal()
{
switch (CurrentState)
{
case State.Start:
{
JsonToken token = (!_readRootValueAsArray) ? JsonToken.StartObject : JsonToken.StartArray;
BsonType type = (!_readRootValueAsArray) ? BsonType.Object : BsonType.Array;
SetToken(token);
ContainerContext newContext = new ContainerContext(type);
PushContext(newContext);
newContext.Length = ReadInt32();
return true;
}
case State.Complete:
case State.Closed:
return false;
case State.Property:
{
ReadType(_currentElementType);
return true;
}
case State.ObjectStart:
case State.ArrayStart:
case State.PostValue:
ContainerContext context = _currentContext;
if (context == null)
{
if (SupportMultipleContent)
{
goto case State.Start;
}
return false;
}
int lengthMinusEnd = context.Length - 1;
if (context.Position < lengthMinusEnd)
{
if (context.Type == BsonType.Array)
{
ReadElement();
ReadType(_currentElementType);
return true;
}
else
{
SetToken(JsonToken.PropertyName, ReadElement());
return true;
}
}
else if (context.Position == lengthMinusEnd)
{
if (ReadByte() != 0)
{
throw JsonReaderException.Create(this, "Unexpected end of object byte value.");
}
PopContext();
if (_currentContext != null)
{
MovePosition(context.Length);
}
JsonToken endToken = (context.Type == BsonType.Object) ? JsonToken.EndObject : JsonToken.EndArray;
SetToken(endToken);
return true;
}
else
{
throw JsonReaderException.Create(this, "Read past end of current container context.");
}
case State.ConstructorStart:
break;
case State.Constructor:
break;
case State.Error:
break;
case State.Finished:
break;
default:
throw new ArgumentOutOfRangeException();
}
return false;
}
private void PopContext()
{
_stack.RemoveAt(_stack.Count - 1);
if (_stack.Count == 0)
{
_currentContext = null;
}
else
{
_currentContext = _stack[_stack.Count - 1];
}
}
private void PushContext(ContainerContext newContext)
{
_stack.Add(newContext);
_currentContext = newContext;
}
private byte ReadByte()
{
MovePosition(1);
return _reader.ReadByte();
}
private void ReadType(BsonType type)
{
switch (type)
{
case BsonType.Number:
double d = ReadDouble();
if (_floatParseHandling == FloatParseHandling.Decimal)
{
SetToken(JsonToken.Float, Convert.ToDecimal(d, CultureInfo.InvariantCulture));
}
else
{
SetToken(JsonToken.Float, d);
}
break;
case BsonType.String:
case BsonType.Symbol:
SetToken(JsonToken.String, ReadLengthString());
break;
case BsonType.Object:
{
SetToken(JsonToken.StartObject);
ContainerContext newContext = new ContainerContext(BsonType.Object);
PushContext(newContext);
newContext.Length = ReadInt32();
break;
}
case BsonType.Array:
{
SetToken(JsonToken.StartArray);
ContainerContext newContext = new ContainerContext(BsonType.Array);
PushContext(newContext);
newContext.Length = ReadInt32();
break;
}
case BsonType.Binary:
BsonBinaryType binaryType;
byte[] data = ReadBinary(out binaryType);
object value = (binaryType != BsonBinaryType.Uuid)
? data
: (object)new Guid(data);
SetToken(JsonToken.Bytes, value);
break;
case BsonType.Undefined:
SetToken(JsonToken.Undefined);
break;
case BsonType.Oid:
byte[] oid = ReadBytes(12);
SetToken(JsonToken.Bytes, oid);
break;
case BsonType.Boolean:
bool b = Convert.ToBoolean(ReadByte());
SetToken(JsonToken.Boolean, b);
break;
case BsonType.Date:
long ticks = ReadInt64();
DateTime utcDateTime = DateTimeUtils.ConvertJavaScriptTicksToDateTime(ticks);
DateTime dateTime;
switch (DateTimeKindHandling)
{
case DateTimeKind.Unspecified:
dateTime = DateTime.SpecifyKind(utcDateTime, DateTimeKind.Unspecified);
break;
case DateTimeKind.Local:
dateTime = utcDateTime.ToLocalTime();
break;
default:
dateTime = utcDateTime;
break;
}
SetToken(JsonToken.Date, dateTime);
break;
case BsonType.Null:
SetToken(JsonToken.Null);
break;
case BsonType.Regex:
string expression = ReadString();
string modifiers = ReadString();
string regex = @"/" + expression + @"/" + modifiers;
SetToken(JsonToken.String, regex);
break;
case BsonType.Reference:
SetToken(JsonToken.StartObject);
_bsonReaderState = BsonReaderState.ReferenceStart;
break;
case BsonType.Code:
SetToken(JsonToken.String, ReadLengthString());
break;
case BsonType.CodeWScope:
SetToken(JsonToken.StartObject);
_bsonReaderState = BsonReaderState.CodeWScopeStart;
break;
case BsonType.Integer:
SetToken(JsonToken.Integer, (long)ReadInt32());
break;
case BsonType.TimeStamp:
case BsonType.Long:
SetToken(JsonToken.Integer, ReadInt64());
break;
default:
throw new ArgumentOutOfRangeException(nameof(type), "Unexpected BsonType value: " + type);
}
}
private byte[] ReadBinary(out BsonBinaryType binaryType)
{
int dataLength = ReadInt32();
binaryType = (BsonBinaryType)ReadByte();
#pragma warning disable 612,618
// the old binary type has the data length repeated in the data for some reason
if (binaryType == BsonBinaryType.BinaryOld && !_jsonNet35BinaryCompatibility)
{
dataLength = ReadInt32();
}
#pragma warning restore 612,618
return ReadBytes(dataLength);
}
private string ReadString()
{
EnsureBuffers();
StringBuilder builder = null;
int totalBytesRead = 0;
// used in case of left over multibyte characters in the buffer
int offset = 0;
while (true)
{
int count = offset;
byte b;
while (count < MaxCharBytesSize && (b = _reader.ReadByte()) > 0)
{
_byteBuffer[count++] = b;
}
int byteCount = count - offset;
totalBytesRead += byteCount;
if (count < MaxCharBytesSize && builder == null)
{
// pref optimization to avoid reading into a string builder
// if string is smaller than the buffer then return it directly
int length = Encoding.UTF8.GetChars(_byteBuffer, 0, byteCount, _charBuffer, 0);
MovePosition(totalBytesRead + 1);
return new string(_charBuffer, 0, length);
}
else
{
// calculate the index of the end of the last full character in the buffer
int lastFullCharStop = GetLastFullCharStop(count - 1);
int charCount = Encoding.UTF8.GetChars(_byteBuffer, 0, lastFullCharStop + 1, _charBuffer, 0);
if (builder == null)
{
builder = new StringBuilder(MaxCharBytesSize * 2);
}
builder.Append(_charBuffer, 0, charCount);
if (lastFullCharStop < byteCount - 1)
{
offset = byteCount - lastFullCharStop - 1;
// copy left over multi byte characters to beginning of buffer for next iteration
Array.Copy(_byteBuffer, lastFullCharStop + 1, _byteBuffer, 0, offset);
}
else
{
// reached end of string
if (count < MaxCharBytesSize)
{
MovePosition(totalBytesRead + 1);
return builder.ToString();
}
offset = 0;
}
}
}
}
private string ReadLengthString()
{
int length = ReadInt32();
MovePosition(length);
string s = GetString(length - 1);
_reader.ReadByte();
return s;
}
private string GetString(int length)
{
if (length == 0)
{
return string.Empty;
}
EnsureBuffers();
StringBuilder builder = null;
int totalBytesRead = 0;
// used in case of left over multibyte characters in the buffer
int offset = 0;
do
{
int count = ((length - totalBytesRead) > MaxCharBytesSize - offset)
? MaxCharBytesSize - offset
: length - totalBytesRead;
int byteCount = _reader.Read(_byteBuffer, offset, count);
if (byteCount == 0)
{
throw new EndOfStreamException("Unable to read beyond the end of the stream.");
}
totalBytesRead += byteCount;
// Above, byteCount is how many bytes we read this time.
// Below, byteCount is how many bytes are in the _byteBuffer.
byteCount += offset;
if (byteCount == length)
{
// pref optimization to avoid reading into a string builder
// first iteration and all bytes read then return string directly
int charCount = Encoding.UTF8.GetChars(_byteBuffer, 0, byteCount, _charBuffer, 0);
return new string(_charBuffer, 0, charCount);
}
else
{
int lastFullCharStop = GetLastFullCharStop(byteCount - 1);
if (builder == null)
{
builder = new StringBuilder(length);
}
int charCount = Encoding.UTF8.GetChars(_byteBuffer, 0, lastFullCharStop + 1, _charBuffer, 0);
builder.Append(_charBuffer, 0, charCount);
if (lastFullCharStop < byteCount - 1)
{
offset = byteCount - lastFullCharStop - 1;
// copy left over multi byte characters to beginning of buffer for next iteration
Array.Copy(_byteBuffer, lastFullCharStop + 1, _byteBuffer, 0, offset);
}
else
{
offset = 0;
}
}
} while (totalBytesRead < length);
return builder.ToString();
}
private int GetLastFullCharStop(int start)
{
int lookbackPos = start;
int bis = 0;
while (lookbackPos >= 0)
{
bis = BytesInSequence(_byteBuffer[lookbackPos]);
if (bis == 0)
{
lookbackPos--;
continue;
}
else if (bis == 1)
{
break;
}
else
{
lookbackPos--;
break;
}
}
if (bis == start - lookbackPos)
{
//Full character.
return start;
}
else
{
return lookbackPos;
}
}
private int BytesInSequence(byte b)
{
if (b <= SeqRange1[1])
{
return 1;
}
if (b >= SeqRange2[0] && b <= SeqRange2[1])
{
return 2;
}
if (b >= SeqRange3[0] && b <= SeqRange3[1])
{
return 3;
}
if (b >= SeqRange4[0] && b <= SeqRange4[1])
{
return 4;
}
return 0;
}
private void EnsureBuffers()
{
if (_byteBuffer == null)
{
_byteBuffer = new byte[MaxCharBytesSize];
}
if (_charBuffer == null)
{
int charBufferSize = Encoding.UTF8.GetMaxCharCount(MaxCharBytesSize);
_charBuffer = new char[charBufferSize];
}
}
private double ReadDouble()
{
MovePosition(8);
return _reader.ReadDouble();
}
private int ReadInt32()
{
MovePosition(4);
return _reader.ReadInt32();
}
private long ReadInt64()
{
MovePosition(8);
return _reader.ReadInt64();
}
private BsonType ReadType()
{
MovePosition(1);
return (BsonType)_reader.ReadSByte();
}
private void MovePosition(int count)
{
_currentContext.Position += count;
}
private byte[] ReadBytes(int count)
{
MovePosition(count);
return _reader.ReadBytes(count);
}
}
}
================================================
FILE: Src/Newtonsoft.Json/Bson/BsonToken.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System.Collections;
using System.Collections.Generic;
#nullable disable
namespace Newtonsoft.Json.Bson
{
internal abstract class BsonToken
{
public abstract BsonType Type { get; }
public BsonToken Parent { get; set; }
public int CalculatedSize { get; set; }
}
internal class BsonObject : BsonToken, IEnumerable
{
private readonly List _children = new List();
public void Add(string name, BsonToken token)
{
_children.Add(new BsonProperty { Name = new BsonString(name, false), Value = token });
token.Parent = this;
}
public override BsonType Type => BsonType.Object;
public IEnumerator GetEnumerator()
{
return _children.GetEnumerator();
}
IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
}
internal class BsonArray : BsonToken, IEnumerable
{
private readonly List _children = new List();
public void Add(BsonToken token)
{
_children.Add(token);
token.Parent = this;
}
public override BsonType Type => BsonType.Array;
public IEnumerator GetEnumerator()
{
return _children.GetEnumerator();
}
IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
}
internal class BsonEmpty : BsonToken
{
public static readonly BsonToken Null = new BsonEmpty(BsonType.Null);
public static readonly BsonToken Undefined = new BsonEmpty(BsonType.Undefined);
private BsonEmpty(BsonType type)
{
Type = type;
}
public override BsonType Type { get; }
}
internal class BsonValue : BsonToken
{
private readonly object _value;
private readonly BsonType _type;
public BsonValue(object value, BsonType type)
{
_value = value;
_type = type;
}
public object Value => _value;
public override BsonType Type => _type;
}
internal class BsonBoolean : BsonValue
{
public static readonly BsonBoolean False = new BsonBoolean(false);
public static readonly BsonBoolean True = new BsonBoolean(true);
private BsonBoolean(bool value)
: base(value, BsonType.Boolean)
{
}
}
internal class BsonString : BsonValue
{
public int ByteCount { get; set; }
public bool IncludeLength { get; }
public BsonString(object value, bool includeLength)
: base(value, BsonType.String)
{
IncludeLength = includeLength;
}
}
internal class BsonBinary : BsonValue
{
public BsonBinaryType BinaryType { get; set; }
public BsonBinary(byte[] value, BsonBinaryType binaryType)
: base(value, BsonType.Binary)
{
BinaryType = binaryType;
}
}
internal class BsonRegex : BsonToken
{
public BsonString Pattern { get; set; }
public BsonString Options { get; set; }
public BsonRegex(string pattern, string options)
{
Pattern = new BsonString(pattern, false);
Options = new BsonString(options, false);
}
public override BsonType Type => BsonType.Regex;
}
internal class BsonProperty
{
public BsonString Name { get; set; }
public BsonToken Value { get; set; }
}
}
================================================
FILE: Src/Newtonsoft.Json/Bson/BsonType.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
#nullable disable
namespace Newtonsoft.Json.Bson
{
internal enum BsonType : sbyte
{
Number = 1,
String = 2,
Object = 3,
Array = 4,
Binary = 5,
Undefined = 6,
Oid = 7,
Boolean = 8,
Date = 9,
Null = 10,
Regex = 11,
Reference = 12,
Code = 13,
Symbol = 14,
CodeWScope = 15,
Integer = 16,
TimeStamp = 17,
Long = 18,
MinKey = -1,
MaxKey = 127
}
}
================================================
FILE: Src/Newtonsoft.Json/Bson/BsonWriter.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
#if HAVE_BIG_INTEGER
using System.Numerics;
#endif
using System.Text;
using Newtonsoft.Json.Utilities;
using Newtonsoft.Json.Linq;
using System.Globalization;
#nullable disable
namespace Newtonsoft.Json.Bson
{
///
/// Represents a writer that provides a fast, non-cached, forward-only way of generating BSON data.
///
[Obsolete("BSON reading and writing has been moved to its own package. See https://www.nuget.org/packages/Newtonsoft.Json.Bson for more details.")]
public class BsonWriter : JsonWriter
{
private readonly BsonBinaryWriter _writer;
private BsonToken _root;
private BsonToken _parent;
private string _propertyName;
///
/// Gets or sets the used when writing values to BSON.
/// When set to no conversion will occur.
///
/// The used when writing values to BSON.
public DateTimeKind DateTimeKindHandling
{
get => _writer.DateTimeKindHandling;
set => _writer.DateTimeKindHandling = value;
}
///
/// Initializes a new instance of the class.
///
/// The to write to.
public BsonWriter(Stream stream)
{
ValidationUtils.ArgumentNotNull(stream, nameof(stream));
_writer = new BsonBinaryWriter(new BinaryWriter(stream));
}
///
/// Initializes a new instance of the class.
///
/// The to write to.
public BsonWriter(BinaryWriter writer)
{
ValidationUtils.ArgumentNotNull(writer, nameof(writer));
_writer = new BsonBinaryWriter(writer);
}
///
/// Flushes whatever is in the buffer to the underlying and also flushes the underlying stream.
///
public override void Flush()
{
_writer.Flush();
}
///
/// Writes the end.
///
/// The token.
protected override void WriteEnd(JsonToken token)
{
base.WriteEnd(token);
RemoveParent();
if (Top == 0)
{
_writer.WriteToken(_root);
}
}
///
/// Writes a comment /*...*/ containing the specified text.
///
/// Text to place inside the comment.
public override void WriteComment(string text)
{
throw JsonWriterException.Create(this, "Cannot write JSON comment as BSON.", null);
}
///
/// Writes the start of a constructor with the given name.
///
/// The name of the constructor.
public override void WriteStartConstructor(string name)
{
throw JsonWriterException.Create(this, "Cannot write JSON constructor as BSON.", null);
}
///
/// Writes raw JSON.
///
/// The raw JSON to write.
public override void WriteRaw(string json)
{
throw JsonWriterException.Create(this, "Cannot write raw JSON as BSON.", null);
}
///
/// Writes raw JSON where a value is expected and updates the writer's state.
///
/// The raw JSON to write.
public override void WriteRawValue(string json)
{
throw JsonWriterException.Create(this, "Cannot write raw JSON as BSON.", null);
}
///
/// Writes the beginning of a JSON array.
///
public override void WriteStartArray()
{
base.WriteStartArray();
AddParent(new BsonArray());
}
///
/// Writes the beginning of a JSON object.
///
public override void WriteStartObject()
{
base.WriteStartObject();
AddParent(new BsonObject());
}
///
/// Writes the property name of a name/value pair on a JSON object.
///
/// The name of the property.
public override void WritePropertyName(string name)
{
base.WritePropertyName(name);
_propertyName = name;
}
///
/// Closes this writer.
/// If is set to true, the underlying is also closed.
/// If is set to true, the JSON is auto-completed.
///
public override void Close()
{
base.Close();
if (CloseOutput)
{
_writer?.Close();
}
}
private void AddParent(BsonToken container)
{
AddToken(container);
_parent = container;
}
private void RemoveParent()
{
_parent = _parent.Parent;
}
private void AddValue(object value, BsonType type)
{
AddToken(new BsonValue(value, type));
}
internal void AddToken(BsonToken token)
{
if (_parent != null)
{
if (_parent is BsonObject bo)
{
bo.Add(_propertyName, token);
_propertyName = null;
}
else
{
((BsonArray)_parent).Add(token);
}
}
else
{
if (token.Type != BsonType.Object && token.Type != BsonType.Array)
{
throw JsonWriterException.Create(this, "Error writing {0} value. BSON must start with an Object or Array.".FormatWith(CultureInfo.InvariantCulture, token.Type), null);
}
_parent = token;
_root = token;
}
}
#region WriteValue methods
///
/// Writes a value.
/// An error will raised if the value cannot be written as a single JSON token.
///
/// The value to write.
public override void WriteValue(object value)
{
#if HAVE_BIG_INTEGER
if (value is BigInteger i)
{
SetWriteState(JsonToken.Integer, null);
AddToken(new BsonBinary(i.ToByteArray(), BsonBinaryType.Binary));
}
else
#endif
{
base.WriteValue(value);
}
}
///
/// Writes a null value.
///
public override void WriteNull()
{
base.WriteNull();
AddToken(BsonEmpty.Null);
}
///
/// Writes an undefined value.
///
public override void WriteUndefined()
{
base.WriteUndefined();
AddToken(BsonEmpty.Undefined);
}
///
/// Writes a value.
///
/// The value to write.
public override void WriteValue(string value)
{
base.WriteValue(value);
AddToken(value == null ? BsonEmpty.Null : new BsonString(value, true));
}
///
/// Writes a value.
///
/// The value to write.
public override void WriteValue(int value)
{
base.WriteValue(value);
AddValue(value, BsonType.Integer);
}
///
/// Writes a value.
///
/// The value to write.
[CLSCompliant(false)]
public override void WriteValue(uint value)
{
if (value > int.MaxValue)
{
throw JsonWriterException.Create(this, "Value is too large to fit in a signed 32 bit integer. BSON does not support unsigned values.", null);
}
base.WriteValue(value);
AddValue(value, BsonType.Integer);
}
///
/// Writes a value.
///
/// The value to write.
public override void WriteValue(long value)
{
base.WriteValue(value);
AddValue(value, BsonType.Long);
}
///
/// Writes a value.
///
/// The value to write.
[CLSCompliant(false)]
public override void WriteValue(ulong value)
{
if (value > long.MaxValue)
{
throw JsonWriterException.Create(this, "Value is too large to fit in a signed 64 bit integer. BSON does not support unsigned values.", null);
}
base.WriteValue(value);
AddValue(value, BsonType.Long);
}
///
/// Writes a value.
///
/// The value to write.
public override void WriteValue(float value)
{
base.WriteValue(value);
AddValue(value, BsonType.Number);
}
///
/// Writes a value.
///
/// The value to write.
public override void WriteValue(double value)
{
base.WriteValue(value);
AddValue(value, BsonType.Number);
}
///
/// Writes a value.
///
/// The value to write.
public override void WriteValue(bool value)
{
base.WriteValue(value);
AddToken(value ? BsonBoolean.True : BsonBoolean.False);
}
///
/// Writes a value.
///
/// The value to write.
public override void WriteValue(short value)
{
base.WriteValue(value);
AddValue(value, BsonType.Integer);
}
///
/// Writes a value.
///
/// The value to write.
[CLSCompliant(false)]
public override void WriteValue(ushort value)
{
base.WriteValue(value);
AddValue(value, BsonType.Integer);
}
///
/// Writes a value.
///
/// The value to write.
public override void WriteValue(char value)
{
base.WriteValue(value);
string s = null;
#if HAVE_CHAR_TO_STRING_WITH_CULTURE
s = value.ToString(CultureInfo.InvariantCulture);
#else
s = value.ToString();
#endif
AddToken(new BsonString(s, true));
}
///
/// Writes a value.
///
/// The value to write.
public override void WriteValue(byte value)
{
base.WriteValue(value);
AddValue(value, BsonType.Integer);
}
///
/// Writes a value.
///
/// The value to write.
[CLSCompliant(false)]
public override void WriteValue(sbyte value)
{
base.WriteValue(value);
AddValue(value, BsonType.Integer);
}
///
/// Writes a value.
///
/// The value to write.
public override void WriteValue(decimal value)
{
base.WriteValue(value);
AddValue(value, BsonType.Number);
}
///
/// Writes a value.
///
/// The value to write.
public override void WriteValue(DateTime value)
{
base.WriteValue(value);
value = DateTimeUtils.EnsureDateTime(value, DateTimeZoneHandling);
AddValue(value, BsonType.Date);
}
#if HAVE_DATE_TIME_OFFSET
///
/// Writes a value.
///
/// The value to write.
public override void WriteValue(DateTimeOffset value)
{
base.WriteValue(value);
AddValue(value, BsonType.Date);
}
#endif
///
/// Writes a [] value.
///
/// The [] value to write.
public override void WriteValue(byte[] value)
{
if (value == null)
{
WriteNull();
return;
}
base.WriteValue(value);
AddToken(new BsonBinary(value, BsonBinaryType.Binary));
}
///
/// Writes a value.
///
/// The value to write.
public override void WriteValue(Guid value)
{
base.WriteValue(value);
AddToken(new BsonBinary(value.ToByteArray(), BsonBinaryType.Uuid));
}
///
/// Writes a value.
///
/// The value to write.
public override void WriteValue(TimeSpan value)
{
base.WriteValue(value);
AddToken(new BsonString(value.ToString(), true));
}
///
/// Writes a value.
///
/// The value to write.
public override void WriteValue(Uri value)
{
if (value == null)
{
WriteNull();
return;
}
base.WriteValue(value);
AddToken(new BsonString(value.ToString(), true));
}
#endregion
///
/// Writes a [] value that represents a BSON object id.
///
/// The Object ID value to write.
public void WriteObjectId(byte[] value)
{
ValidationUtils.ArgumentNotNull(value, nameof(value));
if (value.Length != 12)
{
throw JsonWriterException.Create(this, "An object id must be 12 bytes", null);
}
// hack to update the writer state
SetWriteState(JsonToken.Undefined, null);
AddValue(value, BsonType.Oid);
}
///
/// Writes a BSON regex.
///
/// The regex pattern.
/// The regex options.
public void WriteRegex(string pattern, string options)
{
ValidationUtils.ArgumentNotNull(pattern, nameof(pattern));
// hack to update the writer state
SetWriteState(JsonToken.Undefined, null);
AddToken(new BsonRegex(pattern, options));
}
}
}
================================================
FILE: Src/Newtonsoft.Json/CompatibilitySuppressions.xml
================================================
CP0001T:Newtonsoft.Json.Serialization.Actionlib/net20/Newtonsoft.Json.dlllib/net35/Newtonsoft.Json.dllCP0001T:Newtonsoft.Json.Serialization.Action`2lib/net20/Newtonsoft.Json.dlllib/net35/Newtonsoft.Json.dllCP0001T:Newtonsoft.Json.Serialization.Action`3lib/net20/Newtonsoft.Json.dlllib/net35/Newtonsoft.Json.dllCP0001T:Newtonsoft.Json.Serialization.Action`4lib/net20/Newtonsoft.Json.dlllib/net35/Newtonsoft.Json.dllCP0001T:Newtonsoft.Json.Serialization.Func`1lib/net20/Newtonsoft.Json.dlllib/net35/Newtonsoft.Json.dllCP0001T:Newtonsoft.Json.Serialization.Func`2lib/net20/Newtonsoft.Json.dlllib/net35/Newtonsoft.Json.dllCP0001T:Newtonsoft.Json.Serialization.Func`3lib/net20/Newtonsoft.Json.dlllib/net35/Newtonsoft.Json.dllCP0001T:Newtonsoft.Json.Serialization.Func`4lib/net20/Newtonsoft.Json.dlllib/net35/Newtonsoft.Json.dllCP0001T:Newtonsoft.Json.Serialization.Func`5lib/net20/Newtonsoft.Json.dlllib/net35/Newtonsoft.Json.dllCP0001T:Newtonsoft.Json.SerializationBinderlib/netstandard1.3/Newtonsoft.Json.dlllib/netstandard2.0/Newtonsoft.Json.dllCP0001T:Newtonsoft.Json.TraceLevellib/netstandard1.3/Newtonsoft.Json.dlllib/netstandard2.0/Newtonsoft.Json.dllCP0001T:System.Runtime.Serialization.Formatters.FormatterAssemblyStylelib/netstandard1.3/Newtonsoft.Json.dlllib/netstandard2.0/Newtonsoft.Json.dllCP0002M:Newtonsoft.Json.JsonConvert.get_DefaultSettingslib/net20/Newtonsoft.Json.dlllib/net35/Newtonsoft.Json.dllCP0002M:Newtonsoft.Json.JsonSerializerSettings.get_ReferenceResolverProviderlib/net20/Newtonsoft.Json.dlllib/net35/Newtonsoft.Json.dllCP0002M:Newtonsoft.Json.Serialization.JsonContract.get_DefaultCreatorlib/net20/Newtonsoft.Json.dlllib/net35/Newtonsoft.Json.dllCP0002M:Newtonsoft.Json.Serialization.JsonDictionaryContract.get_DictionaryKeyResolverlib/net20/Newtonsoft.Json.dlllib/net35/Newtonsoft.Json.dllCP0002M:Newtonsoft.Json.Serialization.JsonObjectContract.get_ExtensionDataNameResolverlib/net20/Newtonsoft.Json.dlllib/net35/Newtonsoft.Json.dllCP0002M:Newtonsoft.Json.Serialization.JsonProperty.get_SetIsSpecifiedlib/net20/Newtonsoft.Json.dlllib/net35/Newtonsoft.Json.dllCP0002M:Newtonsoft.Json.JsonSerializer.get_Binderlib/netstandard1.3/Newtonsoft.Json.dlllib/netstandard2.0/Newtonsoft.Json.dllCP0002M:Newtonsoft.Json.JsonSerializerSettings.get_Binderlib/netstandard1.3/Newtonsoft.Json.dlllib/netstandard2.0/Newtonsoft.Json.dllCP0002M:Newtonsoft.Json.Serialization.ITraceWriter.get_LevelFilterlib/netstandard1.3/Newtonsoft.Json.dlllib/netstandard2.0/Newtonsoft.Json.dllCP0002M:Newtonsoft.Json.Serialization.ITraceWriter.Trace(Newtonsoft.Json.TraceLevel,System.String,System.Exception)lib/netstandard1.3/Newtonsoft.Json.dlllib/netstandard2.0/Newtonsoft.Json.dllCP0002M:Newtonsoft.Json.Serialization.MemoryTraceWriter.get_LevelFilterlib/netstandard1.3/Newtonsoft.Json.dlllib/netstandard2.0/Newtonsoft.Json.dllCP0002M:Newtonsoft.Json.Serialization.MemoryTraceWriter.Trace(Newtonsoft.Json.TraceLevel,System.String,System.Exception)lib/netstandard1.3/Newtonsoft.Json.dlllib/netstandard2.0/Newtonsoft.Json.dllCP0006M:Newtonsoft.Json.Serialization.ITraceWriter.Trace(System.Diagnostics.TraceLevel,System.String,System.Exception)lib/netstandard1.3/Newtonsoft.Json.dlllib/netstandard2.0/Newtonsoft.Json.dllCP0006P:Newtonsoft.Json.Serialization.ITraceWriter.LevelFilterlib/netstandard1.3/Newtonsoft.Json.dlllib/netstandard2.0/Newtonsoft.Json.dllCP0007T:Newtonsoft.Json.Serialization.DefaultSerializationBinderlib/netstandard1.3/Newtonsoft.Json.dlllib/netstandard2.0/Newtonsoft.Json.dll
================================================
FILE: Src/Newtonsoft.Json/ConstructorHandling.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
namespace Newtonsoft.Json
{
///
/// Specifies how constructors are used when initializing objects during deserialization by the .
///
public enum ConstructorHandling
{
///
/// First attempt to use the public default constructor, then fall back to a single parameterized constructor, then to the non-public default constructor.
///
Default = 0,
///
/// Json.NET will use a non-public default constructor before falling back to a parameterized constructor.
///
AllowNonPublicDefaultConstructor = 1
}
}
================================================
FILE: Src/Newtonsoft.Json/Converters/BinaryConverter.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
#if HAVE_LINQ || HAVE_ADO_NET
using System;
using System.Globalization;
using Newtonsoft.Json.Utilities;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
#if HAVE_ADO_NET
using System.Data.SqlTypes;
#endif
namespace Newtonsoft.Json.Converters
{
///
/// Converts a binary value to and from a base 64 string value.
///
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public class BinaryConverter : JsonConverter
{
#if HAVE_LINQ
private const string BinaryTypeName = "System.Data.Linq.Binary";
private const string BinaryToArrayName = "ToArray";
private static ReflectionObject? _reflectionObject;
#endif
///
/// Writes the JSON representation of the object.
///
/// The to write to.
/// The value.
/// The calling serializer.
public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
{
if (value == null)
{
writer.WriteNull();
return;
}
byte[] data = GetByteArray(value);
writer.WriteValue(data);
}
private byte[] GetByteArray(object value)
{
#if HAVE_LINQ
if (value.GetType().FullName == BinaryTypeName)
{
EnsureReflectionObject(value.GetType());
MiscellaneousUtils.Assert(_reflectionObject != null);
return (byte[])_reflectionObject.GetValue(value, BinaryToArrayName)!;
}
#endif
#if HAVE_ADO_NET
if (value is SqlBinary binary)
{
return binary.Value;
}
#endif
throw new JsonSerializationException("Unexpected value type when writing binary: {0}".FormatWith(CultureInfo.InvariantCulture, value.GetType()));
}
#if HAVE_LINQ
private static void EnsureReflectionObject(Type t)
{
if (_reflectionObject == null)
{
_reflectionObject = ReflectionObject.Create(t, t.GetConstructor(new[] { typeof(byte[]) }), BinaryToArrayName);
}
}
#endif
///
/// Reads the JSON representation of the object.
///
/// The to read from.
/// Type of the object.
/// The existing value of object being read.
/// The calling serializer.
/// The object value.
public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
if (!ReflectionUtils.IsNullable(objectType))
{
throw JsonSerializationException.Create(reader, "Cannot convert null value to {0}.".FormatWith(CultureInfo.InvariantCulture, objectType));
}
return null;
}
byte[] data;
if (reader.TokenType == JsonToken.StartArray)
{
data = ReadByteArray(reader);
}
else if (reader.TokenType == JsonToken.String)
{
// current token is already at base64 string
// unable to call ReadAsBytes so do it the old fashion way
string encodedData = reader.Value!.ToString()!;
data = Convert.FromBase64String(encodedData);
}
else
{
throw JsonSerializationException.Create(reader, "Unexpected token parsing binary. Expected String or StartArray, got {0}.".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
}
Type t = (ReflectionUtils.IsNullableType(objectType))
? Nullable.GetUnderlyingType(objectType)!
: objectType;
#if HAVE_LINQ
if (t.FullName == BinaryTypeName)
{
EnsureReflectionObject(t);
MiscellaneousUtils.Assert(_reflectionObject != null);
return _reflectionObject.Creator!(data);
}
#endif
#if HAVE_ADO_NET
if (t == typeof(SqlBinary))
{
return new SqlBinary(data);
}
#endif
throw JsonSerializationException.Create(reader, "Unexpected object type when writing binary: {0}".FormatWith(CultureInfo.InvariantCulture, objectType));
}
private byte[] ReadByteArray(JsonReader reader)
{
List byteList = new List();
while (reader.Read())
{
switch (reader.TokenType)
{
case JsonToken.Integer:
byteList.Add(Convert.ToByte(reader.Value, CultureInfo.InvariantCulture));
break;
case JsonToken.EndArray:
return byteList.ToArray();
case JsonToken.Comment:
// skip
break;
default:
throw JsonSerializationException.Create(reader, "Unexpected token when reading bytes: {0}".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
}
}
throw JsonSerializationException.Create(reader, "Unexpected end when reading bytes.");
}
///
/// Determines whether this instance can convert the specified object type.
///
/// Type of the object.
///
/// true if this instance can convert the specified object type; otherwise, false.
///
public override bool CanConvert(Type objectType)
{
#if HAVE_LINQ
if (objectType.FullName == BinaryTypeName)
{
return true;
}
#endif
#if HAVE_ADO_NET
if (objectType == typeof(SqlBinary) || objectType == typeof(SqlBinary?))
{
return true;
}
#endif
return false;
}
}
}
#endif
================================================
FILE: Src/Newtonsoft.Json/Converters/BsonObjectIdConverter.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
using Newtonsoft.Json.Bson;
using System.Globalization;
using Newtonsoft.Json.Utilities;
#nullable disable
namespace Newtonsoft.Json.Converters
{
///
/// Converts a to and from JSON and BSON.
///
[Obsolete("BSON reading and writing has been moved to its own package. See https://www.nuget.org/packages/Newtonsoft.Json.Bson for more details.")]
public class BsonObjectIdConverter : JsonConverter
{
///
/// Writes the JSON representation of the object.
///
/// The to write to.
/// The value.
/// The calling serializer.
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
BsonObjectId objectId = (BsonObjectId)value;
if (writer is BsonWriter bsonWriter)
{
bsonWriter.WriteObjectId(objectId.Value);
}
else
{
writer.WriteValue(objectId.Value);
}
}
///
/// Reads the JSON representation of the object.
///
/// The to read from.
/// Type of the object.
/// The existing value of object being read.
/// The calling serializer.
/// The object value.
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType != JsonToken.Bytes)
{
throw new JsonSerializationException("Expected Bytes but got {0}.".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
}
byte[] value = (byte[])reader.Value;
return new BsonObjectId(value);
}
///
/// Determines whether this instance can convert the specified object type.
///
/// Type of the object.
///
/// true if this instance can convert the specified object type; otherwise, false.
///
public override bool CanConvert(Type objectType)
{
return (objectType == typeof(BsonObjectId));
}
}
}
================================================
FILE: Src/Newtonsoft.Json/Converters/CustomCreationConverter.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
using System.Diagnostics.CodeAnalysis;
using System.Reflection;
using Newtonsoft.Json.Utilities;
namespace Newtonsoft.Json.Converters
{
///
/// Creates a custom object.
///
/// The object type to convert.
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public abstract class CustomCreationConverter : JsonConverter
{
///
/// Writes the JSON representation of the object.
///
/// The to write to.
/// The value.
/// The calling serializer.
public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
{
throw new NotSupportedException("CustomCreationConverter should only be used while deserializing.");
}
///
/// Reads the JSON representation of the object.
///
/// The to read from.
/// Type of the object.
/// The existing value of object being read.
/// The calling serializer.
/// The object value.
public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return null;
}
T value = Create(objectType);
if (value == null)
{
throw new JsonSerializationException("No object created.");
}
serializer.Populate(reader, value);
return value;
}
///
/// Creates an object which will then be populated by the serializer.
///
/// Type of the object.
/// The created object.
public abstract T Create(Type objectType);
///
/// Determines whether this instance can convert the specified object type.
///
/// Type of the object.
///
/// true if this instance can convert the specified object type; otherwise, false.
///
public override bool CanConvert(Type objectType)
{
return typeof(T).IsAssignableFrom(objectType);
}
///
/// Gets a value indicating whether this can write JSON.
///
///
/// true if this can write JSON; otherwise, false.
///
public override bool CanWrite => false;
}
}
================================================
FILE: Src/Newtonsoft.Json/Converters/DataSetConverter.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
#if HAVE_ADO_NET
using System;
using System.Data;
using System.Diagnostics.CodeAnalysis;
using Newtonsoft.Json.Serialization;
using Newtonsoft.Json.Utilities;
namespace Newtonsoft.Json.Converters
{
///
/// Converts a to and from JSON.
///
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public class DataSetConverter : JsonConverter
{
///
/// Writes the JSON representation of the object.
///
/// The to write to.
/// The value.
/// The calling serializer.
public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
{
if (value == null)
{
writer.WriteNull();
return;
}
DataSet dataSet = (DataSet)value;
DefaultContractResolver? resolver = serializer.ContractResolver as DefaultContractResolver;
DataTableConverter converter = new DataTableConverter();
writer.WriteStartObject();
foreach (DataTable table in dataSet.Tables)
{
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(table.TableName) : table.TableName);
converter.WriteJson(writer, table, serializer);
}
writer.WriteEndObject();
}
///
/// Reads the JSON representation of the object.
///
/// The to read from.
/// Type of the object.
/// The existing value of object being read.
/// The calling serializer.
/// The object value.
public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return null;
}
// handle typed datasets
DataSet ds = (objectType == typeof(DataSet))
? new DataSet()
: (DataSet)Activator.CreateInstance(objectType)!;
DataTableConverter converter = new DataTableConverter();
reader.ReadAndAssert();
while (reader.TokenType == JsonToken.PropertyName)
{
DataTable? dt = ds.Tables[(string)reader.Value!];
bool exists = (dt != null);
dt = (DataTable)converter.ReadJson(reader, typeof(DataTable), dt, serializer)!;
if (!exists)
{
ds.Tables.Add(dt);
}
reader.ReadAndAssert();
}
return ds;
}
///
/// Determines whether this instance can convert the specified value type.
///
/// Type of the value.
///
/// true if this instance can convert the specified value type; otherwise, false.
///
public override bool CanConvert(Type valueType)
{
return typeof(DataSet).IsAssignableFrom(valueType);
}
}
}
#endif
================================================
FILE: Src/Newtonsoft.Json/Converters/DataTableConverter.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
#if HAVE_ADO_NET
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using Newtonsoft.Json.Utilities;
using System;
using System.Data;
using Newtonsoft.Json.Serialization;
namespace Newtonsoft.Json.Converters
{
///
/// Converts a to and from JSON.
///
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public class DataTableConverter : JsonConverter
{
///
/// Writes the JSON representation of the object.
///
/// The to write to.
/// The value.
/// The calling serializer.
public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
{
if (value == null)
{
writer.WriteNull();
return;
}
DataTable table = (DataTable)value;
DefaultContractResolver? resolver = serializer.ContractResolver as DefaultContractResolver;
writer.WriteStartArray();
foreach (DataRow row in table.Rows)
{
writer.WriteStartObject();
foreach (DataColumn column in row.Table.Columns)
{
object columnValue = row[column];
if (serializer.NullValueHandling == NullValueHandling.Ignore && (columnValue == null || columnValue == DBNull.Value))
{
continue;
}
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(column.ColumnName) : column.ColumnName);
serializer.Serialize(writer, columnValue);
}
writer.WriteEndObject();
}
writer.WriteEndArray();
}
///
/// Reads the JSON representation of the object.
///
/// The to read from.
/// Type of the object.
/// The existing value of object being read.
/// The calling serializer.
/// The object value.
public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return null;
}
if (!(existingValue is DataTable dt))
{
// handle typed datasets
dt = (objectType == typeof(DataTable))
? new DataTable()
: (DataTable)Activator.CreateInstance(objectType)!;
}
// DataTable is inside a DataSet
// populate the name from the property name
if (reader.TokenType == JsonToken.PropertyName)
{
dt.TableName = (string)reader.Value!;
reader.ReadAndAssert();
if (reader.TokenType == JsonToken.Null)
{
return dt;
}
}
if (reader.TokenType != JsonToken.StartArray)
{
throw JsonSerializationException.Create(reader, "Unexpected JSON token when reading DataTable. Expected StartArray, got {0}.".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
}
reader.ReadAndAssert();
while (reader.TokenType != JsonToken.EndArray)
{
CreateRow(reader, dt, serializer);
reader.ReadAndAssert();
}
return dt;
}
private static void CreateRow(JsonReader reader, DataTable dt, JsonSerializer serializer)
{
DataRow dr = dt.NewRow();
reader.ReadAndAssert();
while (reader.TokenType == JsonToken.PropertyName)
{
string columnName = (string)reader.Value!;
reader.ReadAndAssert();
DataColumn? column = dt.Columns[columnName];
if (column == null)
{
Type columnType = GetColumnDataType(reader);
column = new DataColumn(columnName, columnType);
dt.Columns.Add(column);
}
if (column.DataType == typeof(DataTable))
{
if (reader.TokenType == JsonToken.StartArray)
{
reader.ReadAndAssert();
}
DataTable nestedDt = new DataTable();
while (reader.TokenType != JsonToken.EndArray)
{
CreateRow(reader, nestedDt, serializer);
reader.ReadAndAssert();
}
dr[columnName] = nestedDt;
}
else if (column.DataType.IsArray && column.DataType != typeof(byte[]))
{
if (reader.TokenType == JsonToken.StartArray)
{
reader.ReadAndAssert();
}
List o = new List();
while (reader.TokenType != JsonToken.EndArray)
{
o.Add(reader.Value);
reader.ReadAndAssert();
}
Array destinationArray = Array.CreateInstance(column.DataType.GetElementType()!, o.Count);
((IList)o).CopyTo(destinationArray, 0);
dr[columnName] = destinationArray;
}
else
{
object columnValue = (reader.Value != null)
? serializer.Deserialize(reader, column.DataType) ?? DBNull.Value
: DBNull.Value;
dr[columnName] = columnValue;
}
reader.ReadAndAssert();
}
dr.EndEdit();
dt.Rows.Add(dr);
}
private static Type GetColumnDataType(JsonReader reader)
{
JsonToken tokenType = reader.TokenType;
switch (tokenType)
{
case JsonToken.Integer:
case JsonToken.Boolean:
case JsonToken.Float:
case JsonToken.String:
case JsonToken.Date:
case JsonToken.Bytes:
return reader.ValueType!;
case JsonToken.Null:
case JsonToken.Undefined:
case JsonToken.EndArray:
return typeof(string);
case JsonToken.StartArray:
reader.ReadAndAssert();
if (reader.TokenType == JsonToken.StartObject)
{
return typeof(DataTable); // nested datatable
}
Type arrayType = GetColumnDataType(reader);
return arrayType.MakeArrayType();
default:
throw JsonSerializationException.Create(reader, "Unexpected JSON token when reading DataTable: {0}".FormatWith(CultureInfo.InvariantCulture, tokenType));
}
}
///
/// Determines whether this instance can convert the specified value type.
///
/// Type of the value.
///
/// true if this instance can convert the specified value type; otherwise, false.
///
public override bool CanConvert(Type valueType)
{
return typeof(DataTable).IsAssignableFrom(valueType);
}
}
}
#endif
================================================
FILE: Src/Newtonsoft.Json/Converters/DateTimeConverterBase.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
namespace Newtonsoft.Json.Converters
{
///
/// Provides a base class for converting a to and from JSON.
///
public abstract class DateTimeConverterBase : JsonConverter
{
///
/// Determines whether this instance can convert the specified object type.
///
/// Type of the object.
///
/// true if this instance can convert the specified object type; otherwise, false.
///
public override bool CanConvert(Type objectType)
{
if (objectType == typeof(DateTime) || objectType == typeof(DateTime?))
{
return true;
}
#if HAVE_DATE_TIME_OFFSET
if (objectType == typeof(DateTimeOffset) || objectType == typeof(DateTimeOffset?))
{
return true;
}
#endif
return false;
}
}
}
================================================
FILE: Src/Newtonsoft.Json/Converters/DiscriminatedUnionConverter.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
#if HAVE_FSHARP_TYPES
using Newtonsoft.Json.Linq;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
#if !HAVE_LINQ
using Newtonsoft.Json.Utilities.LinqBridge;
#else
using System.Linq;
#endif
using System.Reflection;
using Newtonsoft.Json.Serialization;
using System.Globalization;
using Newtonsoft.Json.Utilities;
namespace Newtonsoft.Json.Converters
{
///
/// Converts a F# discriminated union type to and from JSON.
///
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public class DiscriminatedUnionConverter : JsonConverter
{
#region UnionDefinition
internal class Union
{
public readonly FSharpFunction TagReader;
public readonly List Cases;
public Union(FSharpFunction tagReader, List cases)
{
TagReader = tagReader;
Cases = cases;
}
}
internal class UnionCase
{
public readonly int Tag;
public readonly string Name;
public readonly PropertyInfo[] Fields;
public readonly FSharpFunction FieldReader;
public readonly FSharpFunction Constructor;
public UnionCase(int tag, string name, PropertyInfo[] fields, FSharpFunction fieldReader, FSharpFunction constructor)
{
Tag = tag;
Name = name;
Fields = fields;
FieldReader = fieldReader;
Constructor = constructor;
}
}
#endregion
private const string CasePropertyName = "Case";
private const string FieldsPropertyName = "Fields";
private static readonly ThreadSafeStore UnionCache = new ThreadSafeStore(CreateUnion);
private static readonly ThreadSafeStore UnionTypeLookupCache = new ThreadSafeStore(CreateUnionTypeLookup);
private static Type CreateUnionTypeLookup(Type t)
{
// this lookup is because cases with fields are derived from union type
// need to get declaring type to avoid duplicate Unions in cache
// hacky but I can't find an API to get the declaring type without GetUnionCases
object[] cases = (object[])FSharpUtils.Instance.GetUnionCases(null, t, null)!;
object caseInfo = cases.First();
Type unionType = (Type)FSharpUtils.Instance.GetUnionCaseInfoDeclaringType(caseInfo)!;
return unionType;
}
private static Union CreateUnion(Type t)
{
Union u = new Union((FSharpFunction)FSharpUtils.Instance.PreComputeUnionTagReader(null, t, null), new List());
object[] cases = (object[])FSharpUtils.Instance.GetUnionCases(null, t, null)!;
foreach (object unionCaseInfo in cases)
{
UnionCase unionCase = new UnionCase(
(int)FSharpUtils.Instance.GetUnionCaseInfoTag(unionCaseInfo),
(string)FSharpUtils.Instance.GetUnionCaseInfoName(unionCaseInfo),
(PropertyInfo[])FSharpUtils.Instance.GetUnionCaseInfoFields(unionCaseInfo)!,
(FSharpFunction)FSharpUtils.Instance.PreComputeUnionReader(null, unionCaseInfo, null),
(FSharpFunction)FSharpUtils.Instance.PreComputeUnionConstructor(null, unionCaseInfo, null));
u.Cases.Add(unionCase);
}
return u;
}
///
/// Writes the JSON representation of the object.
///
/// The to write to.
/// The value.
/// The calling serializer.
public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
{
if (value == null)
{
writer.WriteNull();
return;
}
DefaultContractResolver? resolver = serializer.ContractResolver as DefaultContractResolver;
Type unionType = UnionTypeLookupCache.Get(value.GetType());
Union union = UnionCache.Get(unionType);
int tag = (int)union.TagReader.Invoke(value);
UnionCase caseInfo = union.Cases.Single(c => c.Tag == tag);
writer.WriteStartObject();
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(CasePropertyName) : CasePropertyName);
writer.WriteValue(caseInfo.Name);
if (caseInfo.Fields != null && caseInfo.Fields.Length > 0)
{
object[] fields = (object[])caseInfo.FieldReader.Invoke(value)!;
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(FieldsPropertyName) : FieldsPropertyName);
writer.WriteStartArray();
foreach (object field in fields)
{
serializer.Serialize(writer, field);
}
writer.WriteEndArray();
}
writer.WriteEndObject();
}
///
/// Reads the JSON representation of the object.
///
/// The to read from.
/// Type of the object.
/// The existing value of object being read.
/// The calling serializer.
/// The object value.
public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return null;
}
UnionCase? caseInfo = null;
string? caseName = null;
JArray? fields = null;
// start object
reader.ReadAndAssert();
while (reader.TokenType == JsonToken.PropertyName)
{
string propertyName = reader.Value!.ToString()!;
if (string.Equals(propertyName, CasePropertyName, StringComparison.OrdinalIgnoreCase))
{
reader.ReadAndAssert();
Union union = UnionCache.Get(objectType);
caseName = reader.Value!.ToString();
caseInfo = union.Cases.SingleOrDefault(c => c.Name == caseName);
if (caseInfo == null)
{
throw JsonSerializationException.Create(reader, "No union type found with the name '{0}'.".FormatWith(CultureInfo.InvariantCulture, caseName));
}
}
else if (string.Equals(propertyName, FieldsPropertyName, StringComparison.OrdinalIgnoreCase))
{
reader.ReadAndAssert();
if (reader.TokenType != JsonToken.StartArray)
{
throw JsonSerializationException.Create(reader, "Union fields must been an array.");
}
fields = (JArray)JToken.ReadFrom(reader);
}
else
{
throw JsonSerializationException.Create(reader, "Unexpected property '{0}' found when reading union.".FormatWith(CultureInfo.InvariantCulture, propertyName));
}
reader.ReadAndAssert();
}
if (caseInfo == null)
{
throw JsonSerializationException.Create(reader, "No '{0}' property with union name found.".FormatWith(CultureInfo.InvariantCulture, CasePropertyName));
}
object?[] typedFieldValues = new object?[caseInfo.Fields.Length];
if (caseInfo.Fields.Length > 0 && fields == null)
{
throw JsonSerializationException.Create(reader, "No '{0}' property with union fields found.".FormatWith(CultureInfo.InvariantCulture, FieldsPropertyName));
}
if (fields != null)
{
if (caseInfo.Fields.Length != fields.Count)
{
throw JsonSerializationException.Create(reader, "The number of field values does not match the number of properties defined by union '{0}'.".FormatWith(CultureInfo.InvariantCulture, caseName));
}
for (int i = 0; i < fields.Count; i++)
{
JToken t = fields[i];
PropertyInfo fieldProperty = caseInfo.Fields[i];
typedFieldValues[i] = t.ToObject(fieldProperty.PropertyType, serializer);
}
}
object[] args = { typedFieldValues };
return caseInfo.Constructor.Invoke(args);
}
///
/// Determines whether this instance can convert the specified object type.
///
/// Type of the object.
///
/// true if this instance can convert the specified object type; otherwise, false.
///
public override bool CanConvert(Type objectType)
{
if (typeof(IEnumerable).IsAssignableFrom(objectType))
{
return false;
}
// all fsharp objects have CompilationMappingAttribute
// get the fsharp assembly from the attribute and initialize latebound methods
object[] attributes;
#if HAVE_FULL_REFLECTION
attributes = objectType.GetCustomAttributes(true);
#else
attributes = objectType.GetTypeInfo().GetCustomAttributes(true).ToArray();
#endif
bool isFSharpType = false;
foreach (object attribute in attributes)
{
Type attributeType = attribute.GetType();
if (attributeType.FullName == "Microsoft.FSharp.Core.CompilationMappingAttribute")
{
FSharpUtils.EnsureInitialized(attributeType.Assembly());
isFSharpType = true;
break;
}
}
if (!isFSharpType)
{
return false;
}
return (bool)FSharpUtils.Instance.IsUnion(null, objectType, null);
}
}
}
#endif
================================================
FILE: Src/Newtonsoft.Json/Converters/EntityKeyMemberConverter.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
#if HAVE_ENTITY_FRAMEWORK
using System;
using Newtonsoft.Json.Serialization;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using Newtonsoft.Json.Utilities;
using System.Diagnostics;
namespace Newtonsoft.Json.Converters
{
///
/// Converts an Entity Framework to and from JSON.
///
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public class EntityKeyMemberConverter : JsonConverter
{
private const string EntityKeyMemberFullTypeName = "System.Data.EntityKeyMember";
private const string KeyPropertyName = "Key";
private const string TypePropertyName = "Type";
private const string ValuePropertyName = "Value";
private static ReflectionObject? _reflectionObject;
///
/// Writes the JSON representation of the object.
///
/// The to write to.
/// The value.
/// The calling serializer.
public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
{
if (value == null)
{
writer.WriteNull();
return;
}
EnsureReflectionObject(value.GetType());
MiscellaneousUtils.Assert(_reflectionObject != null);
DefaultContractResolver? resolver = serializer.ContractResolver as DefaultContractResolver;
string keyName = (string)_reflectionObject.GetValue(value, KeyPropertyName)!;
object? keyValue = _reflectionObject.GetValue(value, ValuePropertyName);
Type? keyValueType = keyValue?.GetType();
writer.WriteStartObject();
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(KeyPropertyName) : KeyPropertyName);
writer.WriteValue(keyName);
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(TypePropertyName) : TypePropertyName);
writer.WriteValue(keyValueType?.FullName);
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(ValuePropertyName) : ValuePropertyName);
if (keyValueType != null)
{
if (JsonSerializerInternalWriter.TryConvertToString(keyValue!, keyValueType, out string? valueJson))
{
writer.WriteValue(valueJson);
}
else
{
writer.WriteValue(keyValue);
}
}
else
{
writer.WriteNull();
}
writer.WriteEndObject();
}
private static void ReadAndAssertProperty(JsonReader reader, string propertyName)
{
reader.ReadAndAssert();
if (reader.TokenType != JsonToken.PropertyName || !string.Equals(reader.Value?.ToString(), propertyName, StringComparison.OrdinalIgnoreCase))
{
throw new JsonSerializationException("Expected JSON property '{0}'.".FormatWith(CultureInfo.InvariantCulture, propertyName));
}
}
///
/// Reads the JSON representation of the object.
///
/// The to read from.
/// Type of the object.
/// The existing value of object being read.
/// The calling serializer.
/// The object value.
public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
{
EnsureReflectionObject(objectType);
MiscellaneousUtils.Assert(_reflectionObject != null);
object entityKeyMember = _reflectionObject.Creator!();
ReadAndAssertProperty(reader, KeyPropertyName);
reader.ReadAndAssert();
_reflectionObject.SetValue(entityKeyMember, KeyPropertyName, reader.Value?.ToString());
ReadAndAssertProperty(reader, TypePropertyName);
reader.ReadAndAssert();
string? type = reader.Value?.ToString();
Type t = Type.GetType(type!)!;
ReadAndAssertProperty(reader, ValuePropertyName);
reader.ReadAndAssert();
_reflectionObject.SetValue(entityKeyMember, ValuePropertyName, serializer.Deserialize(reader, t));
reader.ReadAndAssert();
return entityKeyMember;
}
private static void EnsureReflectionObject(Type objectType)
{
if (_reflectionObject == null)
{
_reflectionObject = ReflectionObject.Create(objectType, KeyPropertyName, ValuePropertyName);
}
}
///
/// Determines whether this instance can convert the specified object type.
///
/// Type of the object.
///
/// true if this instance can convert the specified object type; otherwise, false.
///
public override bool CanConvert(Type objectType)
{
return objectType.AssignableToTypeName(EntityKeyMemberFullTypeName);
}
}
}
#endif
================================================
FILE: Src/Newtonsoft.Json/Converters/ExpandoObjectConverter.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
#if HAVE_DYNAMIC
using System;
using System.Collections.Generic;
using System.Dynamic;
using System.Globalization;
using System.Linq;
using System.Text;
using Newtonsoft.Json.Utilities;
namespace Newtonsoft.Json.Converters
{
///
/// Converts an to and from JSON.
///
public class ExpandoObjectConverter : JsonConverter
{
///
/// Writes the JSON representation of the object.
///
/// The to write to.
/// The value.
/// The calling serializer.
public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
{
// can write is set to false
}
///
/// Reads the JSON representation of the object.
///
/// The to read from.
/// Type of the object.
/// The existing value of object being read.
/// The calling serializer.
/// The object value.
public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
{
return ReadValue(reader);
}
private object? ReadValue(JsonReader reader)
{
if (!reader.MoveToContent())
{
throw JsonSerializationException.Create(reader, "Unexpected end when reading ExpandoObject.");
}
switch (reader.TokenType)
{
case JsonToken.StartObject:
return ReadObject(reader);
case JsonToken.StartArray:
return ReadList(reader);
default:
if (JsonTokenUtils.IsPrimitiveToken(reader.TokenType))
{
return reader.Value;
}
throw JsonSerializationException.Create(reader, "Unexpected token when converting ExpandoObject: {0}".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
}
}
private object ReadList(JsonReader reader)
{
IList list = new List();
while (reader.Read())
{
switch (reader.TokenType)
{
case JsonToken.Comment:
break;
default:
object? v = ReadValue(reader);
list.Add(v);
break;
case JsonToken.EndArray:
return list;
}
}
throw JsonSerializationException.Create(reader, "Unexpected end when reading ExpandoObject.");
}
private object ReadObject(JsonReader reader)
{
IDictionary expandoObject = new ExpandoObject();
while (reader.Read())
{
switch (reader.TokenType)
{
case JsonToken.PropertyName:
string propertyName = reader.Value!.ToString()!;
if (!reader.Read())
{
throw JsonSerializationException.Create(reader, "Unexpected end when reading ExpandoObject.");
}
object? v = ReadValue(reader);
expandoObject[propertyName] = v;
break;
case JsonToken.Comment:
break;
case JsonToken.EndObject:
return expandoObject;
}
}
throw JsonSerializationException.Create(reader, "Unexpected end when reading ExpandoObject.");
}
///
/// Determines whether this instance can convert the specified object type.
///
/// Type of the object.
///
/// true if this instance can convert the specified object type; otherwise, false.
///
public override bool CanConvert(Type objectType)
{
return (objectType == typeof(ExpandoObject));
}
///
/// Gets a value indicating whether this can write JSON.
///
///
/// true if this can write JSON; otherwise, false.
///
public override bool CanWrite => false;
}
}
#endif
================================================
FILE: Src/Newtonsoft.Json/Converters/IsoDateTimeConverter.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
using System.Globalization;
using Newtonsoft.Json.Utilities;
namespace Newtonsoft.Json.Converters
{
///
/// Converts a to and from the ISO 8601 date format (e.g. "2008-04-12T12:53Z").
///
public class IsoDateTimeConverter : DateTimeConverterBase
{
private const string DefaultDateTimeFormat = "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK";
private DateTimeStyles _dateTimeStyles = DateTimeStyles.RoundtripKind;
private string? _dateTimeFormat;
private CultureInfo? _culture;
///
/// Gets or sets the date time styles used when converting a date to and from JSON.
///
/// The date time styles used when converting a date to and from JSON.
public DateTimeStyles DateTimeStyles
{
get => _dateTimeStyles;
set => _dateTimeStyles = value;
}
///
/// Gets or sets the date time format used when converting a date to and from JSON.
///
/// The date time format used when converting a date to and from JSON.
public string? DateTimeFormat
{
get => _dateTimeFormat ?? string.Empty;
set => _dateTimeFormat = (StringUtils.IsNullOrEmpty(value)) ? null : value;
}
///
/// Gets or sets the culture used when converting a date to and from JSON.
///
/// The culture used when converting a date to and from JSON.
public CultureInfo Culture
{
get => _culture ?? CultureInfo.CurrentCulture;
set => _culture = value;
}
///
/// Writes the JSON representation of the object.
///
/// The to write to.
/// The value.
/// The calling serializer.
public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
{
string text;
if (value is DateTime dateTime)
{
if ((_dateTimeStyles & DateTimeStyles.AdjustToUniversal) == DateTimeStyles.AdjustToUniversal
|| (_dateTimeStyles & DateTimeStyles.AssumeUniversal) == DateTimeStyles.AssumeUniversal)
{
dateTime = dateTime.ToUniversalTime();
}
text = dateTime.ToString(_dateTimeFormat ?? DefaultDateTimeFormat, Culture);
}
#if HAVE_DATE_TIME_OFFSET
else if (value is DateTimeOffset dateTimeOffset)
{
if ((_dateTimeStyles & DateTimeStyles.AdjustToUniversal) == DateTimeStyles.AdjustToUniversal
|| (_dateTimeStyles & DateTimeStyles.AssumeUniversal) == DateTimeStyles.AssumeUniversal)
{
dateTimeOffset = dateTimeOffset.ToUniversalTime();
}
text = dateTimeOffset.ToString(_dateTimeFormat ?? DefaultDateTimeFormat, Culture);
}
#endif
else
{
throw new JsonSerializationException("Unexpected value when converting date. Expected DateTime or DateTimeOffset, got {0}.".FormatWith(CultureInfo.InvariantCulture, ReflectionUtils.GetObjectType(value)!));
}
writer.WriteValue(text);
}
///
/// Reads the JSON representation of the object.
///
/// The to read from.
/// Type of the object.
/// The existing value of object being read.
/// The calling serializer.
/// The object value.
public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
{
bool nullable = ReflectionUtils.IsNullableType(objectType);
if (reader.TokenType == JsonToken.Null)
{
if (!nullable)
{
throw JsonSerializationException.Create(reader, "Cannot convert null value to {0}.".FormatWith(CultureInfo.InvariantCulture, objectType));
}
return null;
}
#if HAVE_DATE_TIME_OFFSET
Type t = (nullable)
? Nullable.GetUnderlyingType(objectType)!
: objectType;
#endif
if (reader.TokenType == JsonToken.Date)
{
#if HAVE_DATE_TIME_OFFSET
if (t == typeof(DateTimeOffset))
{
return (reader.Value is DateTimeOffset) ? reader.Value : new DateTimeOffset((DateTime)reader.Value!);
}
// converter is expected to return a DateTime
if (reader.Value is DateTimeOffset offset)
{
return offset.DateTime;
}
#endif
return reader.Value;
}
if (reader.TokenType != JsonToken.String)
{
throw JsonSerializationException.Create(reader, "Unexpected token parsing date. Expected String, got {0}.".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
}
string? dateText = reader.Value?.ToString();
if (StringUtils.IsNullOrEmpty(dateText) && nullable)
{
return null;
}
MiscellaneousUtils.Assert(dateText != null);
#if HAVE_DATE_TIME_OFFSET
if (t == typeof(DateTimeOffset))
{
if (!StringUtils.IsNullOrEmpty(_dateTimeFormat))
{
return DateTimeOffset.ParseExact(dateText, _dateTimeFormat, Culture, _dateTimeStyles);
}
else
{
return DateTimeOffset.Parse(dateText, Culture, _dateTimeStyles);
}
}
#endif
if (!StringUtils.IsNullOrEmpty(_dateTimeFormat))
{
return DateTime.ParseExact(dateText, _dateTimeFormat, Culture, _dateTimeStyles);
}
else
{
return DateTime.Parse(dateText, Culture, _dateTimeStyles);
}
}
}
}
================================================
FILE: Src/Newtonsoft.Json/Converters/JavaScriptDateTimeConverter.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
using System.Globalization;
using Newtonsoft.Json.Utilities;
namespace Newtonsoft.Json.Converters
{
///
/// Converts a to and from a JavaScript Date constructor (e.g. new Date(52231943)).
///
public class JavaScriptDateTimeConverter : DateTimeConverterBase
{
///
/// Writes the JSON representation of the object.
///
/// The to write to.
/// The value.
/// The calling serializer.
public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
{
long ticks;
if (value is DateTime dateTime)
{
DateTime utcDateTime = dateTime.ToUniversalTime();
ticks = DateTimeUtils.ConvertDateTimeToJavaScriptTicks(utcDateTime);
}
#if HAVE_DATE_TIME_OFFSET
else if (value is DateTimeOffset dateTimeOffset)
{
DateTimeOffset utcDateTimeOffset = dateTimeOffset.ToUniversalTime();
ticks = DateTimeUtils.ConvertDateTimeToJavaScriptTicks(utcDateTimeOffset.UtcDateTime);
}
#endif
else
{
throw new JsonSerializationException("Expected date object value.");
}
writer.WriteStartConstructor("Date");
writer.WriteValue(ticks);
writer.WriteEndConstructor();
}
///
/// Reads the JSON representation of the object.
///
/// The to read from.
/// Type of the object.
/// The existing property value of the JSON that is being converted.
/// The calling serializer.
/// The object value.
public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
if (!ReflectionUtils.IsNullable(objectType))
{
throw JsonSerializationException.Create(reader, "Cannot convert null value to {0}.".FormatWith(CultureInfo.InvariantCulture, objectType));
}
return null;
}
if (reader.TokenType != JsonToken.StartConstructor || !string.Equals(reader.Value?.ToString(), "Date", StringComparison.Ordinal))
{
throw JsonSerializationException.Create(reader, "Unexpected token or value when parsing date. Token: {0}, Value: {1}".FormatWith(CultureInfo.InvariantCulture, reader.TokenType, reader.Value));
}
if (!JavaScriptUtils.TryGetDateFromConstructorJson(reader, out DateTime d, out string? errorMessage))
{
throw JsonSerializationException.Create(reader, errorMessage);
}
#if HAVE_DATE_TIME_OFFSET
Type t = (ReflectionUtils.IsNullableType(objectType))
? Nullable.GetUnderlyingType(objectType)!
: objectType;
if (t == typeof(DateTimeOffset))
{
return new DateTimeOffset(d);
}
#endif
return d;
}
}
}
================================================
FILE: Src/Newtonsoft.Json/Converters/KeyValuePairConverter.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using Newtonsoft.Json.Serialization;
using Newtonsoft.Json.Utilities;
using System.Reflection;
namespace Newtonsoft.Json.Converters
{
///
/// Converts a to and from JSON.
///
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public class KeyValuePairConverter : JsonConverter
{
private const string KeyName = "Key";
private const string ValueName = "Value";
private static readonly ThreadSafeStore ReflectionObjectPerType = new ThreadSafeStore(InitializeReflectionObject);
private static ReflectionObject InitializeReflectionObject(Type t)
{
IList genericArguments = t.GetGenericArguments();
Type keyType = genericArguments[0];
Type valueType = genericArguments[1];
return ReflectionObject.Create(t, t.GetConstructor(new[] { keyType, valueType }), KeyName, ValueName);
}
///
/// Writes the JSON representation of the object.
///
/// The to write to.
/// The value.
/// The calling serializer.
public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
{
if (value == null)
{
writer.WriteNull();
return;
}
ReflectionObject reflectionObject = ReflectionObjectPerType.Get(value.GetType());
DefaultContractResolver? resolver = serializer.ContractResolver as DefaultContractResolver;
writer.WriteStartObject();
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(KeyName) : KeyName);
serializer.Serialize(writer, reflectionObject.GetValue(value, KeyName), reflectionObject.GetType(KeyName));
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(ValueName) : ValueName);
serializer.Serialize(writer, reflectionObject.GetValue(value, ValueName), reflectionObject.GetType(ValueName));
writer.WriteEndObject();
}
///
/// Reads the JSON representation of the object.
///
/// The to read from.
/// Type of the object.
/// The existing value of object being read.
/// The calling serializer.
/// The object value.
public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
if (!ReflectionUtils.IsNullableType(objectType))
{
throw JsonSerializationException.Create(reader, "Cannot convert null value to KeyValuePair.");
}
return null;
}
object? key = null;
object? value = null;
reader.ReadAndAssert();
Type t = ReflectionUtils.IsNullableType(objectType)
? Nullable.GetUnderlyingType(objectType)!
: objectType;
ReflectionObject reflectionObject = ReflectionObjectPerType.Get(t);
JsonContract keyContract = serializer.ContractResolver.ResolveContract(reflectionObject.GetType(KeyName));
JsonContract valueContract = serializer.ContractResolver.ResolveContract(reflectionObject.GetType(ValueName));
while (reader.TokenType == JsonToken.PropertyName)
{
string propertyName = reader.Value!.ToString()!;
if (string.Equals(propertyName, KeyName, StringComparison.OrdinalIgnoreCase))
{
reader.ReadForTypeAndAssert(keyContract, false);
key = serializer.Deserialize(reader, keyContract.UnderlyingType);
}
else if (string.Equals(propertyName, ValueName, StringComparison.OrdinalIgnoreCase))
{
reader.ReadForTypeAndAssert(valueContract, false);
value = serializer.Deserialize(reader, valueContract.UnderlyingType);
}
else
{
reader.Skip();
}
reader.ReadAndAssert();
}
return reflectionObject.Creator!(key, value);
}
///
/// Determines whether this instance can convert the specified object type.
///
/// Type of the object.
///
/// true if this instance can convert the specified object type; otherwise, false.
///
public override bool CanConvert(Type objectType)
{
Type t = (ReflectionUtils.IsNullableType(objectType))
? Nullable.GetUnderlyingType(objectType)!
: objectType;
if (t.IsValueType() && t.IsGenericType())
{
return (t.GetGenericTypeDefinition() == typeof(KeyValuePair<,>));
}
return false;
}
}
}
================================================
FILE: Src/Newtonsoft.Json/Converters/RegexConverter.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
using System.Diagnostics.CodeAnalysis;
using System.Text.RegularExpressions;
using Newtonsoft.Json.Bson;
using System.Globalization;
using System.Runtime.CompilerServices;
using Newtonsoft.Json.Serialization;
using Newtonsoft.Json.Utilities;
namespace Newtonsoft.Json.Converters
{
///
/// Converts a to and from JSON and BSON.
///
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public class RegexConverter : JsonConverter
{
private const string PatternName = "Pattern";
private const string OptionsName = "Options";
///
/// Writes the JSON representation of the object.
///
/// The to write to.
/// The value.
/// The calling serializer.
public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
{
if (value == null)
{
writer.WriteNull();
return;
}
Regex regex = (Regex)value;
#pragma warning disable 618
if (writer is BsonWriter bsonWriter)
{
WriteBson(bsonWriter, regex);
}
#pragma warning restore 618
else
{
WriteJson(writer, regex, serializer);
}
}
private bool HasFlag(RegexOptions options, RegexOptions flag)
{
return ((options & flag) == flag);
}
#pragma warning disable 618
private void WriteBson(BsonWriter writer, Regex regex)
{
// Regular expression - The first cstring is the regex pattern, the second
// is the regex options string. Options are identified by characters, which
// must be stored in alphabetical order. Valid options are 'i' for case
// insensitive matching, 'm' for multiline matching, 'x' for verbose mode,
// 'l' to make \w, \W, etc. locale dependent, 's' for dotall mode
// ('.' matches everything), and 'u' to make \w, \W, etc. match unicode.
string? options = null;
if (HasFlag(regex.Options, RegexOptions.IgnoreCase))
{
options += "i";
}
if (HasFlag(regex.Options, RegexOptions.Multiline))
{
options += "m";
}
if (HasFlag(regex.Options, RegexOptions.Singleline))
{
options += "s";
}
options += "u";
if (HasFlag(regex.Options, RegexOptions.ExplicitCapture))
{
options += "x";
}
writer.WriteRegex(regex.ToString(), options);
}
#pragma warning restore 618
private void WriteJson(JsonWriter writer, Regex regex, JsonSerializer serializer)
{
DefaultContractResolver? resolver = serializer.ContractResolver as DefaultContractResolver;
writer.WriteStartObject();
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(PatternName) : PatternName);
writer.WriteValue(regex.ToString());
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(OptionsName) : OptionsName);
serializer.Serialize(writer, regex.Options);
writer.WriteEndObject();
}
///
/// Reads the JSON representation of the object.
///
/// The to read from.
/// Type of the object.
/// The existing value of object being read.
/// The calling serializer.
/// The object value.
public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
{
switch (reader.TokenType)
{
case JsonToken.StartObject:
return ReadRegexObject(reader, serializer);
case JsonToken.String:
return ReadRegexString(reader);
case JsonToken.Null:
return null;
}
throw JsonSerializationException.Create(reader, "Unexpected token when reading Regex.");
}
private object ReadRegexString(JsonReader reader)
{
string regexText = (string)reader.Value!;
if (regexText.Length > 0 && regexText[0] == '/')
{
int patternOptionDelimiterIndex = regexText.LastIndexOf('/');
if (patternOptionDelimiterIndex > 0)
{
string patternText = regexText.Substring(1, patternOptionDelimiterIndex - 1);
string optionsText = regexText.Substring(patternOptionDelimiterIndex + 1);
RegexOptions options = MiscellaneousUtils.GetRegexOptions(optionsText);
return new Regex(patternText, options);
}
}
throw JsonSerializationException.Create(reader, "Regex pattern must be enclosed by slashes.");
}
private Regex ReadRegexObject(JsonReader reader, JsonSerializer serializer)
{
string? pattern = null;
RegexOptions? options = null;
while (reader.Read())
{
switch (reader.TokenType)
{
case JsonToken.PropertyName:
string propertyName = reader.Value!.ToString()!;
if (!reader.Read())
{
throw JsonSerializationException.Create(reader, "Unexpected end when reading Regex.");
}
if (string.Equals(propertyName, PatternName, StringComparison.OrdinalIgnoreCase))
{
pattern = (string?)reader.Value;
}
else if (string.Equals(propertyName, OptionsName, StringComparison.OrdinalIgnoreCase))
{
options = serializer.Deserialize(reader);
}
else
{
reader.Skip();
}
break;
case JsonToken.Comment:
break;
case JsonToken.EndObject:
if (pattern == null)
{
throw JsonSerializationException.Create(reader, "Error deserializing Regex. No pattern found.");
}
return new Regex(pattern, options ?? RegexOptions.None);
}
}
throw JsonSerializationException.Create(reader, "Unexpected end when reading Regex.");
}
///
/// Determines whether this instance can convert the specified object type.
///
/// Type of the object.
///
/// true if this instance can convert the specified object type; otherwise, false.
///
public override bool CanConvert(Type objectType)
{
return objectType.Name == nameof(Regex) && IsRegex(objectType);
}
[MethodImpl(MethodImplOptions.NoInlining)]
private bool IsRegex(Type objectType)
{
return (objectType == typeof(Regex));
}
}
}
================================================
FILE: Src/Newtonsoft.Json/Converters/StringEnumConverter.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Reflection;
using System.Runtime.Serialization;
using Newtonsoft.Json.Utilities;
using Newtonsoft.Json.Serialization;
#if !HAVE_LINQ
using Newtonsoft.Json.Utilities.LinqBridge;
#else
using System.Linq;
#endif
namespace Newtonsoft.Json.Converters
{
///
/// Converts an to and from its name string value.
///
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public class StringEnumConverter : JsonConverter
{
///
/// Gets or sets a value indicating whether the written enum text should be camel case.
/// The default value is false.
///
/// true if the written enum text will be camel case; otherwise, false.
[Obsolete("StringEnumConverter.CamelCaseText is obsolete. Set StringEnumConverter.NamingStrategy with CamelCaseNamingStrategy instead.")]
public bool CamelCaseText
{
get => NamingStrategy is CamelCaseNamingStrategy ? true : false;
set
{
if (value)
{
if (NamingStrategy is CamelCaseNamingStrategy)
{
return;
}
NamingStrategy = new CamelCaseNamingStrategy();
}
else
{
if (!(NamingStrategy is CamelCaseNamingStrategy))
{
return;
}
NamingStrategy = null;
}
}
}
///
/// Gets or sets the naming strategy used to resolve how enum text is written.
///
/// The naming strategy used to resolve how enum text is written.
public NamingStrategy? NamingStrategy { get; set; }
///
/// Gets or sets a value indicating whether integer values are allowed when serializing and deserializing.
/// The default value is true.
///
/// true if integers are allowed when serializing and deserializing; otherwise, false.
public bool AllowIntegerValues { get; set; } = true;
///
/// Initializes a new instance of the class.
///
public StringEnumConverter()
{
}
///
/// Initializes a new instance of the class.
///
/// true if the written enum text will be camel case; otherwise, false.
[Obsolete("StringEnumConverter(bool) is obsolete. Create a converter with StringEnumConverter(NamingStrategy, bool) instead.")]
public StringEnumConverter(bool camelCaseText)
{
if (camelCaseText)
{
NamingStrategy = new CamelCaseNamingStrategy();
}
}
///
/// Initializes a new instance of the class.
///
/// The naming strategy used to resolve how enum text is written.
/// true if integers are allowed when serializing and deserializing; otherwise, false.
public StringEnumConverter(NamingStrategy namingStrategy, bool allowIntegerValues = true)
{
NamingStrategy = namingStrategy;
AllowIntegerValues = allowIntegerValues;
}
///
/// Initializes a new instance of the class.
///
/// The of the used to write enum text.
public StringEnumConverter(Type namingStrategyType)
{
ValidationUtils.ArgumentNotNull(namingStrategyType, nameof(namingStrategyType));
NamingStrategy = JsonTypeReflector.CreateNamingStrategyInstance(namingStrategyType, null);
}
///
/// Initializes a new instance of the class.
///
/// The of the used to write enum text.
///
/// The parameter list to use when constructing the described by .
/// If null, the default constructor is used.
/// When non-null, there must be a constructor defined in the that exactly matches the number,
/// order, and type of these parameters.
///
public StringEnumConverter(Type namingStrategyType, object[] namingStrategyParameters)
{
ValidationUtils.ArgumentNotNull(namingStrategyType, nameof(namingStrategyType));
NamingStrategy = JsonTypeReflector.CreateNamingStrategyInstance(namingStrategyType, namingStrategyParameters);
}
///
/// Initializes a new instance of the class.
///
/// The of the used to write enum text.
///
/// The parameter list to use when constructing the described by .
/// If null, the default constructor is used.
/// When non-null, there must be a constructor defined in the that exactly matches the number,
/// order, and type of these parameters.
///
/// true if integers are allowed when serializing and deserializing; otherwise, false.
public StringEnumConverter(Type namingStrategyType, object[] namingStrategyParameters, bool allowIntegerValues)
{
ValidationUtils.ArgumentNotNull(namingStrategyType, nameof(namingStrategyType));
NamingStrategy = JsonTypeReflector.CreateNamingStrategyInstance(namingStrategyType, namingStrategyParameters);
AllowIntegerValues = allowIntegerValues;
}
///
/// Writes the JSON representation of the object.
///
/// The to write to.
/// The value.
/// The calling serializer.
public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
{
if (value == null)
{
writer.WriteNull();
return;
}
Enum e = (Enum)value;
if (!EnumUtils.TryToString(e.GetType(), value, NamingStrategy, out string? enumName))
{
if (!AllowIntegerValues)
{
throw JsonSerializationException.Create(null, writer.ContainerPath, "Integer value {0} is not allowed.".FormatWith(CultureInfo.InvariantCulture, e.ToString("D")), null);
}
// enum value has no name so write number
writer.WriteValue(value);
}
else
{
writer.WriteValue(enumName);
}
}
///
/// Reads the JSON representation of the object.
///
/// The to read from.
/// Type of the object.
/// The existing value of object being read.
/// The calling serializer.
/// The object value.
public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
if (!ReflectionUtils.IsNullableType(objectType))
{
throw JsonSerializationException.Create(reader, "Cannot convert null value to {0}.".FormatWith(CultureInfo.InvariantCulture, objectType));
}
return null;
}
bool isNullable = ReflectionUtils.IsNullableType(objectType);
Type t = isNullable ? Nullable.GetUnderlyingType(objectType)! : objectType;
try
{
if (reader.TokenType == JsonToken.String)
{
string? enumText = reader.Value?.ToString();
if (StringUtils.IsNullOrEmpty(enumText) && isNullable)
{
return null;
}
return EnumUtils.ParseEnum(t, NamingStrategy, enumText!, !AllowIntegerValues);
}
if (reader.TokenType == JsonToken.Integer)
{
if (!AllowIntegerValues)
{
throw JsonSerializationException.Create(reader, "Integer value {0} is not allowed.".FormatWith(CultureInfo.InvariantCulture, reader.Value));
}
return ConvertUtils.ConvertOrCast(reader.Value, CultureInfo.InvariantCulture, t);
}
}
catch (Exception ex)
{
throw JsonSerializationException.Create(reader, "Error converting value {0} to type '{1}'.".FormatWith(CultureInfo.InvariantCulture, MiscellaneousUtils.ToString(reader.Value), objectType), ex);
}
// we don't actually expect to get here.
throw JsonSerializationException.Create(reader, "Unexpected token {0} when parsing enum.".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
}
///
/// Determines whether this instance can convert the specified object type.
///
/// Type of the object.
///
/// true if this instance can convert the specified object type; otherwise, false.
///
public override bool CanConvert(Type objectType)
{
Type t = (ReflectionUtils.IsNullableType(objectType))
? Nullable.GetUnderlyingType(objectType)!
: objectType;
return t.IsEnum();
}
}
}
================================================
FILE: Src/Newtonsoft.Json/Converters/UnixDateTimeConverter.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
using System.Globalization;
using Newtonsoft.Json.Utilities;
namespace Newtonsoft.Json.Converters
{
///
/// Converts a to and from Unix epoch time
///
public class UnixDateTimeConverter : DateTimeConverterBase
{
internal static readonly DateTime UnixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
///
/// Gets or sets a value indicating whether the dates before Unix epoch
/// should converted to and from JSON.
///
///
/// true to allow converting dates before Unix epoch to and from JSON;
/// false to throw an exception when a date being converted to or from JSON
/// occurred before Unix epoch. The default value is false.
///
public bool AllowPreEpoch { get; set; }
///
/// Initializes a new instance of the class.
///
public UnixDateTimeConverter() : this(false)
{
}
///
/// Initializes a new instance of the class.
///
///
/// true to allow converting dates before Unix epoch to and from JSON;
/// false to throw an exception when a date being converted to or from JSON
/// occurred before Unix epoch. The default value is false.
///
public UnixDateTimeConverter(bool allowPreEpoch)
{
AllowPreEpoch = allowPreEpoch;
}
///
/// Writes the JSON representation of the object.
///
/// The to write to.
/// The value.
/// The calling serializer.
public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
{
long seconds;
if (value is DateTime dateTime)
{
seconds = (long)(dateTime.ToUniversalTime() - UnixEpoch).TotalSeconds;
}
#if HAVE_DATE_TIME_OFFSET
else if (value is DateTimeOffset dateTimeOffset)
{
seconds = (long)(dateTimeOffset.ToUniversalTime() - UnixEpoch).TotalSeconds;
}
#endif
else
{
throw new JsonSerializationException("Expected date object value.");
}
if (!AllowPreEpoch && seconds < 0)
{
throw new JsonSerializationException("Cannot convert date value that is before Unix epoch of 00:00:00 UTC on 1 January 1970.");
}
writer.WriteValue(seconds);
}
///
/// Reads the JSON representation of the object.
///
/// The to read from.
/// Type of the object.
/// The existing property value of the JSON that is being converted.
/// The calling serializer.
/// The object value.
public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
{
bool nullable = ReflectionUtils.IsNullable(objectType);
if (reader.TokenType == JsonToken.Null)
{
if (!nullable)
{
throw JsonSerializationException.Create(reader, "Cannot convert null value to {0}.".FormatWith(CultureInfo.InvariantCulture, objectType));
}
return null;
}
long seconds;
if (reader.TokenType == JsonToken.Integer)
{
seconds = (long)reader.Value!;
}
else if (reader.TokenType == JsonToken.String)
{
if (!long.TryParse((string)reader.Value!, out seconds))
{
throw JsonSerializationException.Create(reader, "Cannot convert invalid value to {0}.".FormatWith(CultureInfo.InvariantCulture, objectType));
}
}
else
{
throw JsonSerializationException.Create(reader, "Unexpected token parsing date. Expected Integer or String, got {0}.".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
}
if (AllowPreEpoch || seconds >= 0)
{
DateTime d = UnixEpoch.AddSeconds(seconds);
#if HAVE_DATE_TIME_OFFSET
Type? t = (nullable)
? Nullable.GetUnderlyingType(objectType)
: objectType;
if (t == typeof(DateTimeOffset))
{
return new DateTimeOffset(d, TimeSpan.Zero);
}
#endif
return d;
}
else
{
throw JsonSerializationException.Create(reader, "Cannot convert value that is before Unix epoch of 00:00:00 UTC on 1 January 1970 to {0}.".FormatWith(CultureInfo.InvariantCulture, objectType));
}
}
}
}
================================================
FILE: Src/Newtonsoft.Json/Converters/VersionConverter.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
using System.Globalization;
using Newtonsoft.Json.Utilities;
namespace Newtonsoft.Json.Converters
{
///
/// Converts a to and from a string (e.g. "1.2.3.4").
///
public class VersionConverter : JsonConverter
{
///
/// Writes the JSON representation of the object.
///
/// The to write to.
/// The value.
/// The calling serializer.
public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
{
if (value == null)
{
writer.WriteNull();
}
else if (value is Version)
{
writer.WriteValue(value.ToString());
}
else
{
throw new JsonSerializationException("Expected Version object value");
}
}
///
/// Reads the JSON representation of the object.
///
/// The to read from.
/// Type of the object.
/// The existing property value of the JSON that is being converted.
/// The calling serializer.
/// The object value.
public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return null;
}
else
{
if (reader.TokenType == JsonToken.String)
{
try
{
Version v = new Version((string)reader.Value!);
return v;
}
catch (Exception ex)
{
throw JsonSerializationException.Create(reader, "Error parsing version string: {0}".FormatWith(CultureInfo.InvariantCulture, reader.Value), ex);
}
}
else
{
throw JsonSerializationException.Create(reader, "Unexpected token or value when parsing version. Token: {0}, Value: {1}".FormatWith(CultureInfo.InvariantCulture, reader.TokenType, reader.Value));
}
}
}
///
/// Determines whether this instance can convert the specified object type.
///
/// Type of the object.
///
/// true if this instance can convert the specified object type; otherwise, false.
///
public override bool CanConvert(Type objectType)
{
return objectType == typeof(Version);
}
}
}
================================================
FILE: Src/Newtonsoft.Json/Converters/XmlNodeConverter.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
#if (HAVE_XML_DOCUMENT || HAVE_XLINQ)
#if HAVE_BIG_INTEGER
using System.Numerics;
#endif
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Xml;
using Newtonsoft.Json.Serialization;
#if HAVE_XLINQ
using System.Xml.Linq;
#endif
using Newtonsoft.Json.Utilities;
using System.Runtime.CompilerServices;
using System.Diagnostics.CodeAnalysis;
namespace Newtonsoft.Json.Converters
{
#region XmlNodeWrappers
#if HAVE_XML_DOCUMENT
internal class XmlDocumentWrapper : XmlNodeWrapper, IXmlDocument
{
private readonly XmlDocument _document;
public XmlDocumentWrapper(XmlDocument document)
: base(document)
{
_document = document;
}
public IXmlNode CreateComment(string? data)
{
return new XmlNodeWrapper(_document.CreateComment(data));
}
public IXmlNode CreateTextNode(string? text)
{
return new XmlNodeWrapper(_document.CreateTextNode(text));
}
public IXmlNode CreateCDataSection(string? data)
{
return new XmlNodeWrapper(_document.CreateCDataSection(data));
}
public IXmlNode CreateWhitespace(string? text)
{
return new XmlNodeWrapper(_document.CreateWhitespace(text));
}
public IXmlNode CreateSignificantWhitespace(string? text)
{
return new XmlNodeWrapper(_document.CreateSignificantWhitespace(text));
}
public IXmlNode CreateXmlDeclaration(string version, string? encoding, string? standalone)
{
return new XmlDeclarationWrapper(_document.CreateXmlDeclaration(version, encoding, standalone));
}
#if HAVE_XML_DOCUMENT_TYPE
public IXmlNode CreateXmlDocumentType(string name, string? publicId, string? systemId, string? internalSubset)
{
return new XmlDocumentTypeWrapper(_document.CreateDocumentType(name, publicId, systemId, null));
}
#endif
public IXmlNode CreateProcessingInstruction(string target, string data)
{
return new XmlNodeWrapper(_document.CreateProcessingInstruction(target, data));
}
public IXmlElement CreateElement(string elementName)
{
return new XmlElementWrapper(_document.CreateElement(elementName));
}
public IXmlElement CreateElement(string qualifiedName, string namespaceUri)
{
return new XmlElementWrapper(_document.CreateElement(qualifiedName, namespaceUri));
}
public IXmlNode CreateAttribute(string name, string? value)
{
XmlNodeWrapper attribute = new XmlNodeWrapper(_document.CreateAttribute(name));
attribute.Value = value;
return attribute;
}
public IXmlNode CreateAttribute(string qualifiedName, string? namespaceUri, string? value)
{
XmlNodeWrapper attribute = new XmlNodeWrapper(_document.CreateAttribute(qualifiedName, namespaceUri));
attribute.Value = value;
return attribute;
}
public IXmlElement? DocumentElement
{
get
{
if (_document.DocumentElement == null)
{
return null;
}
return new XmlElementWrapper(_document.DocumentElement);
}
}
}
internal class XmlElementWrapper : XmlNodeWrapper, IXmlElement
{
private readonly XmlElement _element;
public XmlElementWrapper(XmlElement element)
: base(element)
{
_element = element;
}
public void SetAttributeNode(IXmlNode attribute)
{
XmlNodeWrapper xmlAttributeWrapper = (XmlNodeWrapper)attribute;
_element.SetAttributeNode((XmlAttribute)xmlAttributeWrapper.WrappedNode!);
}
public string? GetPrefixOfNamespace(string namespaceUri)
{
return _element.GetPrefixOfNamespace(namespaceUri);
}
public bool IsEmpty => _element.IsEmpty;
}
internal class XmlDeclarationWrapper : XmlNodeWrapper, IXmlDeclaration
{
private readonly XmlDeclaration _declaration;
public XmlDeclarationWrapper(XmlDeclaration declaration)
: base(declaration)
{
_declaration = declaration;
}
public string? Version => _declaration.Version;
public string? Encoding
{
get => _declaration.Encoding;
set => _declaration.Encoding = value;
}
public string? Standalone
{
get => _declaration.Standalone;
set => _declaration.Standalone = value;
}
}
#if HAVE_XML_DOCUMENT_TYPE
internal class XmlDocumentTypeWrapper : XmlNodeWrapper, IXmlDocumentType
{
private readonly XmlDocumentType _documentType;
public XmlDocumentTypeWrapper(XmlDocumentType documentType)
: base(documentType)
{
_documentType = documentType;
}
public string Name => _documentType.Name;
public string? System => _documentType.SystemId;
public string? Public => _documentType.PublicId;
public string? InternalSubset => _documentType.InternalSubset;
public override string? LocalName => "DOCTYPE";
}
#endif
internal class XmlNodeWrapper : IXmlNode
{
private readonly XmlNode _node;
private List? _childNodes;
private List? _attributes;
public XmlNodeWrapper(XmlNode node)
{
_node = node;
}
public object? WrappedNode => _node;
public XmlNodeType NodeType => _node.NodeType;
public virtual string? LocalName => _node.LocalName;
public List ChildNodes
{
get
{
// childnodes is read multiple times
// cache results to prevent multiple reads which kills perf in large documents
if (_childNodes == null)
{
if (!_node.HasChildNodes)
{
_childNodes = XmlNodeConverter.EmptyChildNodes;
}
else
{
_childNodes = new List(_node.ChildNodes.Count);
foreach (XmlNode childNode in _node.ChildNodes)
{
_childNodes.Add(WrapNode(childNode));
}
}
}
return _childNodes;
}
}
protected virtual bool HasChildNodes => _node.HasChildNodes;
internal static IXmlNode WrapNode(XmlNode node)
{
switch (node.NodeType)
{
case XmlNodeType.Element:
return new XmlElementWrapper((XmlElement)node);
case XmlNodeType.XmlDeclaration:
return new XmlDeclarationWrapper((XmlDeclaration)node);
#if HAVE_XML_DOCUMENT_TYPE
case XmlNodeType.DocumentType:
return new XmlDocumentTypeWrapper((XmlDocumentType)node);
#endif
default:
return new XmlNodeWrapper(node);
}
}
public List Attributes
{
get
{
// attributes is read multiple times
// cache results to prevent multiple reads which kills perf in large documents
if (_attributes == null)
{
if (!HasAttributes)
{
_attributes = XmlNodeConverter.EmptyChildNodes;
}
else
{
_attributes = new List(_node.Attributes!.Count);
foreach (XmlAttribute attribute in _node.Attributes)
{
_attributes.Add(WrapNode(attribute));
}
}
}
return _attributes;
}
}
private bool HasAttributes
{
get
{
if (_node is XmlElement element)
{
return element.HasAttributes;
}
return _node.Attributes?.Count > 0;
}
}
public IXmlNode? ParentNode
{
get
{
XmlNode? node = _node is XmlAttribute attribute ? attribute.OwnerElement : _node.ParentNode;
if (node == null)
{
return null;
}
return WrapNode(node);
}
}
public string? Value
{
get => _node.Value;
set => _node.Value = value;
}
public IXmlNode AppendChild(IXmlNode newChild)
{
XmlNodeWrapper xmlNodeWrapper = (XmlNodeWrapper)newChild;
_node.AppendChild(xmlNodeWrapper._node);
_childNodes = null;
_attributes = null;
return newChild;
}
public string? NamespaceUri => _node.NamespaceURI;
}
#endif
#endregion
#region Interfaces
internal interface IXmlDocument : IXmlNode
{
IXmlNode CreateComment(string? text);
IXmlNode CreateTextNode(string? text);
IXmlNode CreateCDataSection(string? data);
IXmlNode CreateWhitespace(string? text);
IXmlNode CreateSignificantWhitespace(string? text);
IXmlNode CreateXmlDeclaration(string version, string? encoding, string? standalone);
#if HAVE_XML_DOCUMENT_TYPE
IXmlNode CreateXmlDocumentType(string name, string? publicId, string? systemId, string? internalSubset);
#endif
IXmlNode CreateProcessingInstruction(string target, string data);
IXmlElement CreateElement(string elementName);
IXmlElement CreateElement(string qualifiedName, string namespaceUri);
IXmlNode CreateAttribute(string name, string value);
IXmlNode CreateAttribute(string qualifiedName, string namespaceUri, string value);
IXmlElement? DocumentElement { get; }
}
internal interface IXmlDeclaration : IXmlNode
{
string? Version { get; }
string? Encoding { get; set; }
string? Standalone { get; set; }
}
internal interface IXmlDocumentType : IXmlNode
{
string Name { get; }
string? System { get; }
string? Public { get; }
string? InternalSubset { get; }
}
internal interface IXmlElement : IXmlNode
{
void SetAttributeNode(IXmlNode attribute);
string? GetPrefixOfNamespace(string namespaceUri);
bool IsEmpty { get; }
}
internal interface IXmlNode
{
XmlNodeType NodeType { get; }
string? LocalName { get; }
List ChildNodes { get; }
List Attributes { get; }
IXmlNode? ParentNode { get; }
string? Value { get; set; }
IXmlNode AppendChild(IXmlNode newChild);
string? NamespaceUri { get; }
object? WrappedNode { get; }
}
#endregion
#region XNodeWrappers
#if HAVE_XLINQ
internal class XDeclarationWrapper : XObjectWrapper, IXmlDeclaration
{
internal XDeclaration Declaration { get; }
public XDeclarationWrapper(XDeclaration declaration)
: base(null)
{
Declaration = declaration;
}
public override XmlNodeType NodeType => XmlNodeType.XmlDeclaration;
public string? Version => Declaration.Version;
public string? Encoding
{
get => Declaration.Encoding;
set => Declaration.Encoding = value;
}
public string? Standalone
{
get => Declaration.Standalone;
set => Declaration.Standalone = value;
}
}
internal class XDocumentTypeWrapper : XObjectWrapper, IXmlDocumentType
{
private readonly XDocumentType _documentType;
public XDocumentTypeWrapper(XDocumentType documentType)
: base(documentType)
{
_documentType = documentType;
}
public string Name => _documentType.Name;
public string? System => _documentType.SystemId;
public string? Public => _documentType.PublicId;
public string? InternalSubset => _documentType.InternalSubset;
public override string? LocalName => "DOCTYPE";
}
internal class XDocumentWrapper : XContainerWrapper, IXmlDocument
{
private XDocument Document => (XDocument)WrappedNode!;
public XDocumentWrapper(XDocument document)
: base(document)
{
}
public override List ChildNodes
{
get
{
List childNodes = base.ChildNodes;
if (Document.Declaration != null && (childNodes.Count == 0 || childNodes[0].NodeType != XmlNodeType.XmlDeclaration))
{
childNodes.Insert(0, new XDeclarationWrapper(Document.Declaration));
}
return childNodes;
}
}
protected override bool HasChildNodes
{
get
{
if (base.HasChildNodes)
{
return true;
}
return Document.Declaration != null;
}
}
public IXmlNode CreateComment(string? text)
{
return new XObjectWrapper(new XComment(text!));
}
public IXmlNode CreateTextNode(string? text)
{
return new XObjectWrapper(new XText(text!));
}
public IXmlNode CreateCDataSection(string? data)
{
return new XObjectWrapper(new XCData(data!));
}
public IXmlNode CreateWhitespace(string? text)
{
return new XObjectWrapper(new XText(text!));
}
public IXmlNode CreateSignificantWhitespace(string? text)
{
return new XObjectWrapper(new XText(text!));
}
public IXmlNode CreateXmlDeclaration(string version, string? encoding, string? standalone)
{
return new XDeclarationWrapper(new XDeclaration(version, encoding, standalone));
}
public IXmlNode CreateXmlDocumentType(string name, string? publicId, string? systemId, string? internalSubset)
{
return new XDocumentTypeWrapper(new XDocumentType(name, publicId, systemId, internalSubset));
}
public IXmlNode CreateProcessingInstruction(string target, string data)
{
return new XProcessingInstructionWrapper(new XProcessingInstruction(target, data));
}
public IXmlElement CreateElement(string elementName)
{
return new XElementWrapper(new XElement(elementName));
}
public IXmlElement CreateElement(string qualifiedName, string namespaceUri)
{
string localName = MiscellaneousUtils.GetLocalName(qualifiedName);
return new XElementWrapper(new XElement(XName.Get(localName, namespaceUri)));
}
public IXmlNode CreateAttribute(string name, string value)
{
return new XAttributeWrapper(new XAttribute(name, value));
}
public IXmlNode CreateAttribute(string qualifiedName, string namespaceUri, string value)
{
string localName = MiscellaneousUtils.GetLocalName(qualifiedName);
return new XAttributeWrapper(new XAttribute(XName.Get(localName, namespaceUri), value));
}
public IXmlElement? DocumentElement
{
get
{
if (Document.Root == null)
{
return null;
}
return new XElementWrapper(Document.Root);
}
}
public override IXmlNode AppendChild(IXmlNode newChild)
{
if (newChild is XDeclarationWrapper declarationWrapper)
{
Document.Declaration = declarationWrapper.Declaration;
return declarationWrapper;
}
else
{
return base.AppendChild(newChild);
}
}
}
internal class XTextWrapper : XObjectWrapper
{
private XText Text => (XText)WrappedNode!;
public XTextWrapper(XText text)
: base(text)
{
}
public override string? Value
{
get => Text.Value;
set => Text.Value = value ?? string.Empty;
}
public override IXmlNode? ParentNode
{
get
{
if (Text.Parent == null)
{
return null;
}
return XContainerWrapper.WrapNode(Text.Parent);
}
}
}
internal class XCommentWrapper : XObjectWrapper
{
private XComment Text => (XComment)WrappedNode!;
public XCommentWrapper(XComment text)
: base(text)
{
}
public override string? Value
{
get => Text.Value;
set => Text.Value = value ?? string.Empty;
}
public override IXmlNode? ParentNode
{
get
{
if (Text.Parent == null)
{
return null;
}
return XContainerWrapper.WrapNode(Text.Parent);
}
}
}
internal class XProcessingInstructionWrapper : XObjectWrapper
{
private XProcessingInstruction ProcessingInstruction => (XProcessingInstruction)WrappedNode!;
public XProcessingInstructionWrapper(XProcessingInstruction processingInstruction)
: base(processingInstruction)
{
}
public override string? LocalName => ProcessingInstruction.Target;
public override string? Value
{
get => ProcessingInstruction.Data;
set => ProcessingInstruction.Data = value ?? string.Empty;
}
}
internal class XContainerWrapper : XObjectWrapper
{
private List? _childNodes;
private XContainer Container => (XContainer)WrappedNode!;
public XContainerWrapper(XContainer container)
: base(container)
{
}
public override List ChildNodes
{
get
{
// childnodes is read multiple times
// cache results to prevent multiple reads which kills perf in large documents
if (_childNodes == null)
{
if (!HasChildNodes)
{
_childNodes = XmlNodeConverter.EmptyChildNodes;
}
else
{
_childNodes = new List();
foreach (XNode node in Container.Nodes())
{
_childNodes.Add(WrapNode(node));
}
}
}
return _childNodes;
}
}
protected virtual bool HasChildNodes => Container.LastNode != null;
public override IXmlNode? ParentNode
{
get
{
if (Container.Parent == null)
{
return null;
}
return WrapNode(Container.Parent);
}
}
internal static IXmlNode WrapNode(XObject node)
{
if (node is XDocument document)
{
return new XDocumentWrapper(document);
}
if (node is XElement element)
{
return new XElementWrapper(element);
}
if (node is XContainer container)
{
return new XContainerWrapper(container);
}
if (node is XProcessingInstruction pi)
{
return new XProcessingInstructionWrapper(pi);
}
if (node is XText text)
{
return new XTextWrapper(text);
}
if (node is XComment comment)
{
return new XCommentWrapper(comment);
}
if (node is XAttribute attribute)
{
return new XAttributeWrapper(attribute);
}
if (node is XDocumentType type)
{
return new XDocumentTypeWrapper(type);
}
return new XObjectWrapper(node);
}
public override IXmlNode AppendChild(IXmlNode newChild)
{
Container.Add(newChild.WrappedNode);
_childNodes = null;
return newChild;
}
}
internal class XObjectWrapper : IXmlNode
{
private readonly XObject? _xmlObject;
public XObjectWrapper(XObject? xmlObject)
{
_xmlObject = xmlObject;
}
public object? WrappedNode => _xmlObject;
public virtual XmlNodeType NodeType => _xmlObject?.NodeType ?? XmlNodeType.None;
public virtual string? LocalName => null;
public virtual List ChildNodes => XmlNodeConverter.EmptyChildNodes;
public virtual List Attributes => XmlNodeConverter.EmptyChildNodes;
public virtual IXmlNode? ParentNode => null;
public virtual string? Value
{
get => null;
set => throw new InvalidOperationException();
}
public virtual IXmlNode AppendChild(IXmlNode newChild)
{
throw new InvalidOperationException();
}
public virtual string? NamespaceUri => null;
}
internal class XAttributeWrapper : XObjectWrapper
{
private XAttribute Attribute => (XAttribute)WrappedNode!;
public XAttributeWrapper(XAttribute attribute)
: base(attribute)
{
}
public override string? Value
{
get => Attribute.Value;
set => Attribute.Value = value ?? string.Empty;
}
public override string? LocalName => Attribute.Name.LocalName;
public override string? NamespaceUri => Attribute.Name.NamespaceName;
public override IXmlNode? ParentNode
{
get
{
if (Attribute.Parent == null)
{
return null;
}
return XContainerWrapper.WrapNode(Attribute.Parent);
}
}
}
internal class XElementWrapper : XContainerWrapper, IXmlElement
{
private List? _attributes;
private XElement Element => (XElement)WrappedNode!;
public XElementWrapper(XElement element)
: base(element)
{
}
public void SetAttributeNode(IXmlNode attribute)
{
XObjectWrapper wrapper = (XObjectWrapper)attribute;
Element.Add(wrapper.WrappedNode);
_attributes = null;
}
public override List Attributes
{
get
{
// attributes is read multiple times
// cache results to prevent multiple reads which kills perf in large documents
if (_attributes == null)
{
if (!Element.HasAttributes && !HasImplicitNamespaceAttribute(NamespaceUri!))
{
_attributes = XmlNodeConverter.EmptyChildNodes;
}
else
{
_attributes = new List();
foreach (XAttribute attribute in Element.Attributes())
{
_attributes.Add(new XAttributeWrapper(attribute));
}
// ensure elements created with a namespace but no namespace attribute are converted correctly
// e.g. new XElement("{http://example.com}MyElement");
string namespaceUri = NamespaceUri!;
if (HasImplicitNamespaceAttribute(namespaceUri))
{
_attributes.Insert(0, new XAttributeWrapper(new XAttribute("xmlns", namespaceUri)));
}
}
}
return _attributes;
}
}
private bool HasImplicitNamespaceAttribute(string namespaceUri)
{
if (!StringUtils.IsNullOrEmpty(namespaceUri) && namespaceUri != ParentNode?.NamespaceUri)
{
if (StringUtils.IsNullOrEmpty(GetPrefixOfNamespace(namespaceUri)))
{
bool namespaceDeclared = false;
if (Element.HasAttributes)
{
foreach (XAttribute attribute in Element.Attributes())
{
if (attribute.Name.LocalName == "xmlns" && StringUtils.IsNullOrEmpty(attribute.Name.NamespaceName) && attribute.Value == namespaceUri)
{
namespaceDeclared = true;
}
}
}
if (!namespaceDeclared)
{
return true;
}
}
}
return false;
}
public override IXmlNode AppendChild(IXmlNode newChild)
{
IXmlNode result = base.AppendChild(newChild);
_attributes = null;
return result;
}
public override string? Value
{
get => Element.Value;
set => Element.Value = value ?? string.Empty;
}
public override string? LocalName => Element.Name.LocalName;
public override string? NamespaceUri => Element.Name.NamespaceName;
public string? GetPrefixOfNamespace(string namespaceUri)
{
return Element.GetPrefixOfNamespace(namespaceUri);
}
public bool IsEmpty => Element.IsEmpty;
}
#endif
#endregion
///
/// Converts XML to and from JSON.
///
public class XmlNodeConverter : JsonConverter
{
internal static readonly List EmptyChildNodes = new List();
private const string TextName = "#text";
private const string CommentName = "#comment";
private const string CDataName = "#cdata-section";
private const string WhitespaceName = "#whitespace";
private const string SignificantWhitespaceName = "#significant-whitespace";
private const string DeclarationName = "?xml";
private const string JsonNamespaceUri = "http://james.newtonking.com/projects/json";
///
/// Gets or sets the name of the root element to insert when deserializing to XML if the JSON structure has produced multiple root elements.
///
/// The name of the deserialized root element.
public string? DeserializeRootElementName { get; set; }
///
/// Gets or sets a value to indicate whether to write the Json.NET array attribute.
/// This attribute helps preserve arrays when converting the written XML back to JSON.
///
/// true if the array attribute is written to the XML; otherwise, false.
public bool WriteArrayAttribute { get; set; }
///
/// Gets or sets a value indicating whether to write the root JSON object.
///
/// true if the JSON root object is omitted; otherwise, false.
public bool OmitRootObject { get; set; }
///
/// Gets or sets a value indicating whether to encode special characters when converting JSON to XML.
/// If true, special characters like ':', '@', '?', '#' and '$' in JSON property names aren't used to specify
/// XML namespaces, attributes or processing directives. Instead special characters are encoded and written
/// as part of the XML element name.
///
/// true if special characters are encoded; otherwise, false.
public bool EncodeSpecialCharacters { get; set; }
#region Writing
///
/// Writes the JSON representation of the object.
///
/// The to write to.
/// The calling serializer.
/// The value.
public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
{
if (value == null)
{
writer.WriteNull();
return;
}
IXmlNode node = WrapXml(value);
XmlNamespaceManager manager = new XmlNamespaceManager(new NameTable());
PushParentNamespaces(node, manager);
if (!OmitRootObject)
{
writer.WriteStartObject();
}
SerializeNode(writer, node, manager, !OmitRootObject);
if (!OmitRootObject)
{
writer.WriteEndObject();
}
}
private IXmlNode WrapXml(object value)
{
#if HAVE_XLINQ
if (value is XObject xObject)
{
return XContainerWrapper.WrapNode(xObject);
}
#endif
#if HAVE_XML_DOCUMENT
if (value is XmlNode node)
{
return XmlNodeWrapper.WrapNode(node);
}
#endif
throw new ArgumentException("Value must be an XML object.", nameof(value));
}
private void PushParentNamespaces(IXmlNode node, XmlNamespaceManager manager)
{
List? parentElements = null;
IXmlNode? parent = node;
while ((parent = parent.ParentNode) != null)
{
if (parent.NodeType == XmlNodeType.Element)
{
if (parentElements == null)
{
parentElements = new List();
}
parentElements.Add(parent);
}
}
if (parentElements != null)
{
parentElements.Reverse();
foreach (IXmlNode parentElement in parentElements)
{
manager.PushScope();
foreach (IXmlNode attribute in parentElement.Attributes)
{
if (attribute.NamespaceUri == "http://www.w3.org/2000/xmlns/" && attribute.LocalName != "xmlns")
{
manager.AddNamespace(attribute.LocalName!, attribute.Value!);
}
}
}
}
}
private string ResolveFullName(IXmlNode node, XmlNamespaceManager manager)
{
string? prefix = (node.NamespaceUri == null || (node.LocalName == "xmlns" && node.NamespaceUri == "http://www.w3.org/2000/xmlns/"))
? null
: manager.LookupPrefix(node.NamespaceUri);
if (!StringUtils.IsNullOrEmpty(prefix))
{
return prefix + ":" + XmlConvert.DecodeName(node.LocalName);
}
else
{
return XmlConvert.DecodeName(node.LocalName)!;
}
}
private string GetPropertyName(IXmlNode node, XmlNamespaceManager manager)
{
switch (node.NodeType)
{
case XmlNodeType.Attribute:
if (node.NamespaceUri == JsonNamespaceUri)
{
return "$" + node.LocalName;
}
else
{
return "@" + ResolveFullName(node, manager);
}
case XmlNodeType.CDATA:
return CDataName;
case XmlNodeType.Comment:
return CommentName;
case XmlNodeType.Element:
if (node.NamespaceUri == JsonNamespaceUri)
{
return "$" + node.LocalName;
}
else
{
return ResolveFullName(node, manager);
}
case XmlNodeType.ProcessingInstruction:
return "?" + ResolveFullName(node, manager);
case XmlNodeType.DocumentType:
return "!" + ResolveFullName(node, manager);
case XmlNodeType.XmlDeclaration:
return DeclarationName;
case XmlNodeType.SignificantWhitespace:
return SignificantWhitespaceName;
case XmlNodeType.Text:
return TextName;
case XmlNodeType.Whitespace:
return WhitespaceName;
default:
throw new JsonSerializationException("Unexpected XmlNodeType when getting node name: " + node.NodeType);
}
}
private bool IsArray(IXmlNode node)
{
foreach (IXmlNode attribute in node.Attributes)
{
if (attribute.LocalName == "Array" && attribute.NamespaceUri == JsonNamespaceUri)
{
return XmlConvert.ToBoolean(attribute.Value!);
}
}
return false;
}
private void SerializeGroupedNodes(JsonWriter writer, IXmlNode node, XmlNamespaceManager manager, bool writePropertyName)
{
switch (node.ChildNodes.Count)
{
case 0:
{
// nothing to serialize
break;
}
case 1:
{
// avoid grouping when there is only one node
string nodeName = GetPropertyName(node.ChildNodes[0], manager);
WriteGroupedNodes(writer, manager, writePropertyName, node.ChildNodes, nodeName);
break;
}
default:
{
// check whether nodes have the same name
// if they don't then group into dictionary together by name
// value of dictionary will be a single IXmlNode when there is one for a name,
// or a List when there are multiple
Dictionary? nodesGroupedByName = null;
string? nodeName = null;
for (int i = 0; i < node.ChildNodes.Count; i++)
{
IXmlNode childNode = node.ChildNodes[i];
string currentNodeName = GetPropertyName(childNode, manager);
if (nodesGroupedByName == null)
{
if (nodeName == null)
{
nodeName = currentNodeName;
}
else if (currentNodeName == nodeName)
{
// current node name matches others
}
else
{
nodesGroupedByName = new Dictionary();
if (i > 1)
{
List nodes = new List(i);
for (int j = 0; j < i; j++)
{
nodes.Add(node.ChildNodes[j]);
}
nodesGroupedByName.Add(nodeName, nodes);
}
else
{
nodesGroupedByName.Add(nodeName, node.ChildNodes[0]);
}
nodesGroupedByName.Add(currentNodeName, childNode);
}
}
else
{
if (!nodesGroupedByName.TryGetValue(currentNodeName, out object? value))
{
nodesGroupedByName.Add(currentNodeName, childNode);
}
else
{
if (!(value is List nodes))
{
nodes = new List {(IXmlNode)value!};
nodesGroupedByName[currentNodeName] = nodes;
}
nodes.Add(childNode);
}
}
}
if (nodesGroupedByName == null)
{
WriteGroupedNodes(writer, manager, writePropertyName, node.ChildNodes, nodeName!);
}
else
{
// loop through grouped nodes. write single name instances as normal,
// write multiple names together in an array
foreach (KeyValuePair nodeNameGroup in nodesGroupedByName)
{
if (nodeNameGroup.Value is List nodes)
{
WriteGroupedNodes(writer, manager, writePropertyName, nodes, nodeNameGroup.Key);
}
else
{
WriteGroupedNodes(writer, manager, writePropertyName, (IXmlNode)nodeNameGroup.Value, nodeNameGroup.Key);
}
}
}
break;
}
}
}
private void WriteGroupedNodes(JsonWriter writer, XmlNamespaceManager manager, bool writePropertyName, List groupedNodes, string elementNames)
{
bool writeArray = groupedNodes.Count != 1 || IsArray(groupedNodes[0]);
if (!writeArray)
{
SerializeNode(writer, groupedNodes[0], manager, writePropertyName);
}
else
{
if (writePropertyName)
{
writer.WritePropertyName(elementNames);
}
writer.WriteStartArray();
for (int i = 0; i < groupedNodes.Count; i++)
{
SerializeNode(writer, groupedNodes[i], manager, false);
}
writer.WriteEndArray();
}
}
private void WriteGroupedNodes(JsonWriter writer, XmlNamespaceManager manager, bool writePropertyName, IXmlNode node, string elementNames)
{
bool writeArray = IsArray(node);
if (!writeArray)
{
SerializeNode(writer, node, manager, writePropertyName);
}
else
{
if (writePropertyName)
{
writer.WritePropertyName(elementNames);
}
writer.WriteStartArray();
SerializeNode(writer, node, manager, false);
writer.WriteEndArray();
}
}
private void SerializeNode(JsonWriter writer, IXmlNode node, XmlNamespaceManager manager, bool writePropertyName)
{
switch (node.NodeType)
{
case XmlNodeType.Document:
case XmlNodeType.DocumentFragment:
SerializeGroupedNodes(writer, node, manager, writePropertyName);
break;
case XmlNodeType.Element:
if (IsArray(node) && AllSameName(node) && node.ChildNodes.Count > 0)
{
SerializeGroupedNodes(writer, node, manager, false);
}
else
{
manager.PushScope();
foreach (IXmlNode attribute in node.Attributes)
{
if (attribute.NamespaceUri == "http://www.w3.org/2000/xmlns/")
{
string namespacePrefix = (attribute.LocalName != "xmlns")
? XmlConvert.DecodeName(attribute.LocalName)!
: string.Empty;
string? namespaceUri = attribute.Value;
if (namespaceUri == null)
{
throw new JsonSerializationException("Namespace attribute must have a value.");
}
manager.AddNamespace(namespacePrefix, namespaceUri);
}
}
if (writePropertyName)
{
writer.WritePropertyName(GetPropertyName(node, manager));
}
if (!ValueAttributes(node.Attributes) && node.ChildNodes.Count == 1
&& node.ChildNodes[0].NodeType == XmlNodeType.Text)
{
// write elements with a single text child as a name value pair
writer.WriteValue(node.ChildNodes[0].Value);
}
else if (node.ChildNodes.Count == 0 && node.Attributes.Count == 0)
{
IXmlElement element = (IXmlElement)node;
// empty element
if (element.IsEmpty)
{
writer.WriteNull();
}
else
{
writer.WriteValue(string.Empty);
}
}
else
{
writer.WriteStartObject();
for (int i = 0; i < node.Attributes.Count; i++)
{
SerializeNode(writer, node.Attributes[i], manager, true);
}
SerializeGroupedNodes(writer, node, manager, true);
writer.WriteEndObject();
}
manager.PopScope();
}
break;
case XmlNodeType.Comment:
if (writePropertyName)
{
writer.WriteComment(node.Value);
}
break;
case XmlNodeType.Attribute:
case XmlNodeType.Text:
case XmlNodeType.CDATA:
case XmlNodeType.ProcessingInstruction:
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
if (node.NamespaceUri == "http://www.w3.org/2000/xmlns/" && node.Value == JsonNamespaceUri)
{
return;
}
if (node.NamespaceUri == JsonNamespaceUri)
{
if (node.LocalName == "Array")
{
return;
}
}
if (writePropertyName)
{
writer.WritePropertyName(GetPropertyName(node, manager));
}
writer.WriteValue(node.Value);
break;
case XmlNodeType.XmlDeclaration:
IXmlDeclaration declaration = (IXmlDeclaration)node;
writer.WritePropertyName(GetPropertyName(node, manager));
writer.WriteStartObject();
if (!StringUtils.IsNullOrEmpty(declaration.Version))
{
writer.WritePropertyName("@version");
writer.WriteValue(declaration.Version);
}
if (!StringUtils.IsNullOrEmpty(declaration.Encoding))
{
writer.WritePropertyName("@encoding");
writer.WriteValue(declaration.Encoding);
}
if (!StringUtils.IsNullOrEmpty(declaration.Standalone))
{
writer.WritePropertyName("@standalone");
writer.WriteValue(declaration.Standalone);
}
writer.WriteEndObject();
break;
case XmlNodeType.DocumentType:
IXmlDocumentType documentType = (IXmlDocumentType)node;
writer.WritePropertyName(GetPropertyName(node, manager));
writer.WriteStartObject();
if (!StringUtils.IsNullOrEmpty(documentType.Name))
{
writer.WritePropertyName("@name");
writer.WriteValue(documentType.Name);
}
if (!StringUtils.IsNullOrEmpty(documentType.Public))
{
writer.WritePropertyName("@public");
writer.WriteValue(documentType.Public);
}
if (!StringUtils.IsNullOrEmpty(documentType.System))
{
writer.WritePropertyName("@system");
writer.WriteValue(documentType.System);
}
if (!StringUtils.IsNullOrEmpty(documentType.InternalSubset))
{
writer.WritePropertyName("@internalSubset");
writer.WriteValue(documentType.InternalSubset);
}
writer.WriteEndObject();
break;
default:
throw new JsonSerializationException("Unexpected XmlNodeType when serializing nodes: " + node.NodeType);
}
}
private static bool AllSameName(IXmlNode node)
{
foreach (IXmlNode childNode in node.ChildNodes)
{
if (childNode.LocalName != node.LocalName)
{
return false;
}
}
return true;
}
#endregion
#region Reading
///
/// Reads the JSON representation of the object.
///
/// The to read from.
/// Type of the object.
/// The existing value of object being read.
/// The calling serializer.
/// The object value.
public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
{
switch (reader.TokenType)
{
case JsonToken.Null:
return null;
case JsonToken.StartObject:
break;
default:
throw JsonSerializationException.Create(reader, "XmlNodeConverter can only convert JSON that begins with an object.");
}
XmlNamespaceManager manager = new XmlNamespaceManager(new NameTable());
IXmlDocument? document = null;
IXmlNode? rootNode = null;
#if HAVE_XLINQ
if (typeof(XObject).IsAssignableFrom(objectType))
{
if (objectType != typeof(XContainer)
&& objectType != typeof(XDocument)
&& objectType != typeof(XElement)
&& objectType != typeof(XNode)
&& objectType != typeof(XObject))
{
throw JsonSerializationException.Create(reader, "XmlNodeConverter only supports deserializing XDocument, XElement, XContainer, XNode or XObject.");
}
XDocument d = new XDocument();
document = new XDocumentWrapper(d);
rootNode = document;
}
#endif
#if HAVE_XML_DOCUMENT
if (typeof(XmlNode).IsAssignableFrom(objectType))
{
if (objectType != typeof(XmlDocument)
&& objectType != typeof(XmlElement)
&& objectType != typeof(XmlNode))
{
throw JsonSerializationException.Create(reader, "XmlNodeConverter only supports deserializing XmlDocument, XmlElement or XmlNode.");
}
XmlDocument d = new XmlDocument();
#if HAVE_XML_DOCUMENT_TYPE
// prevent http request when resolving any DTD references
d.XmlResolver = null;
#endif
document = new XmlDocumentWrapper(d);
rootNode = document;
}
#endif
if (document == null || rootNode == null)
{
throw JsonSerializationException.Create(reader, "Unexpected type when converting XML: " + objectType);
}
if (!StringUtils.IsNullOrEmpty(DeserializeRootElementName))
{
ReadElement(reader, document, rootNode, DeserializeRootElementName, manager);
}
else
{
reader.ReadAndAssert();
DeserializeNode(reader, document, manager, rootNode);
}
#if HAVE_XLINQ
if (objectType == typeof(XElement))
{
XElement element = (XElement)document.DocumentElement!.WrappedNode!;
element.Remove();
return element;
}
#endif
#if HAVE_XML_DOCUMENT
if (objectType == typeof(XmlElement))
{
return document.DocumentElement!.WrappedNode;
}
#endif
return document.WrappedNode;
}
private void DeserializeValue(JsonReader reader, IXmlDocument document, XmlNamespaceManager manager, string propertyName, IXmlNode currentNode)
{
if (!EncodeSpecialCharacters)
{
switch (propertyName)
{
case TextName:
currentNode.AppendChild(document.CreateTextNode(ConvertTokenToXmlValue(reader)));
return;
case CDataName:
currentNode.AppendChild(document.CreateCDataSection(ConvertTokenToXmlValue(reader)));
return;
case WhitespaceName:
currentNode.AppendChild(document.CreateWhitespace(ConvertTokenToXmlValue(reader)));
return;
case SignificantWhitespaceName:
currentNode.AppendChild(document.CreateSignificantWhitespace(ConvertTokenToXmlValue(reader)));
return;
default:
// processing instructions and the xml declaration start with ?
if (!StringUtils.IsNullOrEmpty(propertyName) && propertyName[0] == '?')
{
CreateInstruction(reader, document, currentNode, propertyName);
return;
}
#if HAVE_XML_DOCUMENT_TYPE
else if (string.Equals(propertyName, "!DOCTYPE", StringComparison.OrdinalIgnoreCase))
{
CreateDocumentType(reader, document, currentNode);
return;
}
#endif
break;
}
}
if (reader.TokenType == JsonToken.StartArray)
{
// handle nested arrays
ReadArrayElements(reader, document, propertyName, currentNode, manager);
return;
}
// have to wait until attributes have been parsed before creating element
// attributes may contain namespace info used by the element
ReadElement(reader, document, currentNode, propertyName, manager);
}
private void ReadElement(JsonReader reader, IXmlDocument document, IXmlNode currentNode, string propertyName, XmlNamespaceManager manager)
{
if (StringUtils.IsNullOrEmpty(propertyName))
{
throw JsonSerializationException.Create(reader, "XmlNodeConverter cannot convert JSON with an empty property name to XML.");
}
Dictionary? attributeNameValues = null;
string? elementPrefix = null;
if (!EncodeSpecialCharacters)
{
attributeNameValues = ShouldReadInto(reader)
? ReadAttributeElements(reader, manager)
: null;
elementPrefix = MiscellaneousUtils.GetPrefix(propertyName);
if (propertyName.StartsWith('@'))
{
string attributeName = propertyName.Substring(1);
string? attributePrefix = MiscellaneousUtils.GetPrefix(attributeName);
AddAttribute(reader, document, currentNode, propertyName, attributeName, manager, attributePrefix);
return;
}
if (propertyName.StartsWith('$'))
{
switch (propertyName)
{
case JsonTypeReflector.ArrayValuesPropertyName:
propertyName = propertyName.Substring(1);
elementPrefix = manager.LookupPrefix(JsonNamespaceUri);
CreateElement(reader, document, currentNode, propertyName, manager, elementPrefix, attributeNameValues);
return;
case JsonTypeReflector.IdPropertyName:
case JsonTypeReflector.RefPropertyName:
case JsonTypeReflector.TypePropertyName:
case JsonTypeReflector.ValuePropertyName:
string attributeName = propertyName.Substring(1);
string? attributePrefix = manager.LookupPrefix(JsonNamespaceUri);
AddAttribute(reader, document, currentNode, propertyName, attributeName, manager, attributePrefix);
return;
}
}
}
else
{
if (ShouldReadInto(reader))
{
reader.ReadAndAssert();
}
}
CreateElement(reader, document, currentNode, propertyName, manager, elementPrefix, attributeNameValues);
}
private void CreateElement(JsonReader reader, IXmlDocument document, IXmlNode currentNode, string elementName, XmlNamespaceManager manager, string? elementPrefix, Dictionary? attributeNameValues)
{
IXmlElement element = CreateElement(elementName, document, elementPrefix, manager);
currentNode.AppendChild(element);
if (attributeNameValues != null)
{
// add attributes to newly created element
foreach (KeyValuePair nameValue in attributeNameValues)
{
string encodedName = XmlConvert.EncodeName(nameValue.Key);
string? attributePrefix = MiscellaneousUtils.GetPrefix(nameValue.Key);
IXmlNode attribute = (!StringUtils.IsNullOrEmpty(attributePrefix))
? document.CreateAttribute(encodedName, manager.LookupNamespace(attributePrefix) ?? string.Empty, nameValue.Value!)
: document.CreateAttribute(encodedName, nameValue.Value!);
element.SetAttributeNode(attribute);
}
}
switch (reader.TokenType)
{
case JsonToken.String:
case JsonToken.Integer:
case JsonToken.Float:
case JsonToken.Boolean:
case JsonToken.Date:
case JsonToken.Bytes:
string? text = ConvertTokenToXmlValue(reader);
if (text != null)
{
element.AppendChild(document.CreateTextNode(text));
}
break;
case JsonToken.Null:
// empty element. do nothing
break;
case JsonToken.EndObject:
// finished element will have no children to deserialize
manager.RemoveNamespace(string.Empty, manager.DefaultNamespace);
break;
default:
manager.PushScope();
DeserializeNode(reader, document, manager, element);
manager.PopScope();
manager.RemoveNamespace(string.Empty, manager.DefaultNamespace);
break;
}
}
private static void AddAttribute(JsonReader reader, IXmlDocument document, IXmlNode currentNode, string propertyName, string attributeName, XmlNamespaceManager manager, string? attributePrefix)
{
if (currentNode.NodeType == XmlNodeType.Document)
{
throw JsonSerializationException.Create(reader, "JSON root object has property '{0}' that will be converted to an attribute. A root object cannot have any attribute properties. Consider specifying a DeserializeRootElementName.".FormatWith(CultureInfo.InvariantCulture, propertyName));
}
string encodedName = XmlConvert.EncodeName(attributeName);
string attributeValue = ConvertTokenToXmlValue(reader)!;
IXmlNode attribute = (!StringUtils.IsNullOrEmpty(attributePrefix))
? document.CreateAttribute(encodedName, manager.LookupNamespace(attributePrefix)!, attributeValue)
: document.CreateAttribute(encodedName, attributeValue);
((IXmlElement)currentNode).SetAttributeNode(attribute);
}
private static string? ConvertTokenToXmlValue(JsonReader reader)
{
switch (reader.TokenType)
{
case JsonToken.String:
return reader.Value?.ToString();
case JsonToken.Integer:
#if HAVE_BIG_INTEGER
if (reader.Value is BigInteger i)
{
return i.ToString(CultureInfo.InvariantCulture);
}
#endif
return XmlConvert.ToString(Convert.ToInt64(reader.Value, CultureInfo.InvariantCulture));
case JsonToken.Float:
{
if (reader.Value is decimal d)
{
return XmlConvert.ToString(d);
}
if (reader.Value is float f)
{
return XmlConvert.ToString(f);
}
return XmlConvert.ToString(Convert.ToDouble(reader.Value, CultureInfo.InvariantCulture));
}
case JsonToken.Boolean:
return XmlConvert.ToString(Convert.ToBoolean(reader.Value, CultureInfo.InvariantCulture));
case JsonToken.Date:
{
#if HAVE_DATE_TIME_OFFSET
if (reader.Value is DateTimeOffset offset)
{
return XmlConvert.ToString(offset);
}
#endif
DateTime d = Convert.ToDateTime(reader.Value, CultureInfo.InvariantCulture);
#if !PORTABLE || NETSTANDARD1_3
return XmlConvert.ToString(d, DateTimeUtils.ToSerializationMode(d.Kind));
#else
return d.ToString(DateTimeUtils.ToDateTimeFormat(d.Kind), CultureInfo.InvariantCulture);
#endif
}
case JsonToken.Bytes:
return Convert.ToBase64String((byte[])reader.Value!);
case JsonToken.Null:
return null;
default:
throw JsonSerializationException.Create(reader, "Cannot get an XML string value from token type '{0}'.".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
}
}
private void ReadArrayElements(JsonReader reader, IXmlDocument document, string propertyName, IXmlNode currentNode, XmlNamespaceManager manager)
{
string encodeName = EncodeSpecialCharacters ? XmlConvert.EncodeLocalName(propertyName) : XmlConvert.EncodeName(propertyName);
string? elementPrefix = MiscellaneousUtils.GetPrefix(encodeName);
IXmlElement nestedArrayElement = CreateElement(propertyName, document, elementPrefix, manager);
currentNode.AppendChild(nestedArrayElement);
int count = 0;
while (reader.Read() && reader.TokenType != JsonToken.EndArray)
{
DeserializeValue(reader, document, manager, propertyName, nestedArrayElement);
count++;
}
if (WriteArrayAttribute)
{
AddJsonArrayAttribute(nestedArrayElement, document);
}
if (count == 1 && WriteArrayAttribute)
{
foreach (IXmlNode childNode in nestedArrayElement.ChildNodes)
{
if (childNode is IXmlElement element && element.LocalName == encodeName)
{
AddJsonArrayAttribute(element, document);
break;
}
}
}
}
private void AddJsonArrayAttribute(IXmlElement element, IXmlDocument document)
{
var jsonArrayAttributeExists = element.Attributes.Find(x => x.LocalName == "Array" && x.NamespaceUri == JsonNamespaceUri) is not null;
if (jsonArrayAttributeExists)
{
return;
}
element.SetAttributeNode(document.CreateAttribute("json:Array", JsonNamespaceUri, "true"));
#if HAVE_XLINQ
// linq to xml doesn't automatically include prefixes via the namespace manager
if (element is XElementWrapper)
{
if (element.GetPrefixOfNamespace(JsonNamespaceUri) == null)
{
element.SetAttributeNode(document.CreateAttribute("xmlns:json", "http://www.w3.org/2000/xmlns/", JsonNamespaceUri));
}
}
#endif
}
private bool ShouldReadInto(JsonReader reader)
{
// a string token means the element only has a single text child
switch (reader.TokenType)
{
case JsonToken.String:
case JsonToken.Null:
case JsonToken.Boolean:
case JsonToken.Integer:
case JsonToken.Float:
case JsonToken.Date:
case JsonToken.Bytes:
case JsonToken.StartConstructor:
return false;
}
return true;
}
private Dictionary? ReadAttributeElements(JsonReader reader, XmlNamespaceManager manager)
{
Dictionary? attributeNameValues = null;
bool finished = false;
// read properties until first non-attribute is encountered
while (!finished && reader.Read())
{
switch (reader.TokenType)
{
case JsonToken.PropertyName:
string attributeName = reader.Value!.ToString()!;
if (!StringUtils.IsNullOrEmpty(attributeName))
{
char firstChar = attributeName[0];
string? attributeValue;
switch (firstChar)
{
case '@':
if (attributeNameValues == null)
{
attributeNameValues = new Dictionary();
}
attributeName = attributeName.Substring(1);
reader.ReadAndAssert();
attributeValue = ConvertTokenToXmlValue(reader);
attributeNameValues.Add(attributeName, attributeValue);
if (IsNamespaceAttribute(attributeName, out string? namespacePrefix))
{
manager.AddNamespace(namespacePrefix, attributeValue!);
}
break;
case '$':
switch (attributeName)
{
case JsonTypeReflector.ArrayValuesPropertyName:
case JsonTypeReflector.IdPropertyName:
case JsonTypeReflector.RefPropertyName:
case JsonTypeReflector.TypePropertyName:
case JsonTypeReflector.ValuePropertyName:
// check that JsonNamespaceUri is in scope
// if it isn't then add it to document and namespace manager
string? jsonPrefix = manager.LookupPrefix(JsonNamespaceUri);
if (jsonPrefix == null)
{
if (attributeNameValues == null)
{
attributeNameValues = new Dictionary();
}
// ensure that the prefix used is free
int? i = null;
while (manager.LookupNamespace("json" + i) != null)
{
i = i.GetValueOrDefault() + 1;
}
jsonPrefix = "json" + i;
attributeNameValues.Add("xmlns:" + jsonPrefix, JsonNamespaceUri);
manager.AddNamespace(jsonPrefix, JsonNamespaceUri);
}
// special case $values, it will have a non-primitive value
if (attributeName == JsonTypeReflector.ArrayValuesPropertyName)
{
finished = true;
break;
}
attributeName = attributeName.Substring(1);
reader.ReadAndAssert();
if (!JsonTokenUtils.IsPrimitiveToken(reader.TokenType))
{
throw JsonSerializationException.Create(reader, "Unexpected JsonToken: " + reader.TokenType);
}
if (attributeNameValues == null)
{
attributeNameValues = new Dictionary();
}
attributeValue = reader.Value?.ToString();
attributeNameValues.Add(jsonPrefix + ":" + attributeName, attributeValue);
break;
default:
finished = true;
break;
}
break;
default:
finished = true;
break;
}
}
else
{
finished = true;
}
break;
case JsonToken.EndObject:
case JsonToken.Comment:
finished = true;
break;
default:
throw JsonSerializationException.Create(reader, "Unexpected JsonToken: " + reader.TokenType);
}
}
return attributeNameValues;
}
private void CreateInstruction(JsonReader reader, IXmlDocument document, IXmlNode currentNode, string propertyName)
{
if (propertyName == DeclarationName)
{
string? version = null;
string? encoding = null;
string? standalone = null;
while (reader.Read() && reader.TokenType != JsonToken.EndObject)
{
switch (reader.Value?.ToString())
{
case "@version":
reader.ReadAndAssert();
version = ConvertTokenToXmlValue(reader);
break;
case "@encoding":
reader.ReadAndAssert();
encoding = ConvertTokenToXmlValue(reader);
break;
case "@standalone":
reader.ReadAndAssert();
standalone = ConvertTokenToXmlValue(reader);
break;
default:
throw JsonSerializationException.Create(reader, "Unexpected property name encountered while deserializing XmlDeclaration: " + reader.Value);
}
}
if (version == null)
{
throw JsonSerializationException.Create(reader, "Version not specified for XML declaration.");
}
IXmlNode declaration = document.CreateXmlDeclaration(version, encoding, standalone);
currentNode.AppendChild(declaration);
}
else
{
IXmlNode instruction = document.CreateProcessingInstruction(propertyName.Substring(1), ConvertTokenToXmlValue(reader)!);
currentNode.AppendChild(instruction);
}
}
#if HAVE_XML_DOCUMENT_TYPE
private void CreateDocumentType(JsonReader reader, IXmlDocument document, IXmlNode currentNode)
{
string? name = null;
string? publicId = null;
string? systemId = null;
string? internalSubset = null;
while (reader.Read() && reader.TokenType != JsonToken.EndObject)
{
switch (reader.Value?.ToString())
{
case "@name":
reader.ReadAndAssert();
name = ConvertTokenToXmlValue(reader);
break;
case "@public":
reader.ReadAndAssert();
publicId = ConvertTokenToXmlValue(reader);
break;
case "@system":
reader.ReadAndAssert();
systemId = ConvertTokenToXmlValue(reader);
break;
case "@internalSubset":
reader.ReadAndAssert();
internalSubset = ConvertTokenToXmlValue(reader);
break;
default:
throw JsonSerializationException.Create(reader, "Unexpected property name encountered while deserializing XmlDeclaration: " + reader.Value);
}
}
if (name == null)
{
throw JsonSerializationException.Create(reader, "Name not specified for XML document type.");
}
IXmlNode documentType = document.CreateXmlDocumentType(name, publicId, systemId, internalSubset);
currentNode.AppendChild(documentType);
}
#endif
private IXmlElement CreateElement(string elementName, IXmlDocument document, string? elementPrefix, XmlNamespaceManager manager)
{
string encodeName = EncodeSpecialCharacters ? XmlConvert.EncodeLocalName(elementName) : XmlConvert.EncodeName(elementName);
string? ns = StringUtils.IsNullOrEmpty(elementPrefix) ? manager.DefaultNamespace : manager.LookupNamespace(elementPrefix);
IXmlElement element = (!StringUtils.IsNullOrEmpty(ns)) ? document.CreateElement(encodeName, ns) : document.CreateElement(encodeName);
return element;
}
private void DeserializeNode(JsonReader reader, IXmlDocument document, XmlNamespaceManager manager, IXmlNode currentNode)
{
do
{
switch (reader.TokenType)
{
case JsonToken.PropertyName:
if (currentNode.NodeType == XmlNodeType.Document && document.DocumentElement != null)
{
throw JsonSerializationException.Create(reader, "JSON root object has multiple properties. The root object must have a single property in order to create a valid XML document. Consider specifying a DeserializeRootElementName.");
}
string propertyName = reader.Value!.ToString()!;
reader.ReadAndAssert();
if (reader.TokenType == JsonToken.StartArray)
{
int count = 0;
while (reader.Read() && reader.TokenType != JsonToken.EndArray)
{
DeserializeValue(reader, document, manager, propertyName, currentNode);
count++;
}
if (count == 1 && WriteArrayAttribute)
{
string encodeName = EncodeSpecialCharacters ? XmlConvert.EncodeLocalName(propertyName) : XmlConvert.EncodeName(propertyName);
MiscellaneousUtils.GetQualifiedNameParts(encodeName, out string? elementPrefix, out string localName);
string? ns = StringUtils.IsNullOrEmpty(elementPrefix) ? manager.DefaultNamespace : manager.LookupNamespace(elementPrefix);
foreach (IXmlNode childNode in currentNode.ChildNodes)
{
if (childNode is IXmlElement element && element.LocalName == localName && element.NamespaceUri == ns)
{
AddJsonArrayAttribute(element, document);
break;
}
}
}
}
else
{
DeserializeValue(reader, document, manager, propertyName, currentNode);
}
continue;
case JsonToken.StartConstructor:
string constructorName = reader.Value!.ToString()!;
while (reader.Read() && reader.TokenType != JsonToken.EndConstructor)
{
DeserializeValue(reader, document, manager, constructorName, currentNode);
}
break;
case JsonToken.Comment:
currentNode.AppendChild(document.CreateComment((string)reader.Value!));
break;
case JsonToken.EndObject:
case JsonToken.EndArray:
return;
default:
throw JsonSerializationException.Create(reader, "Unexpected JsonToken when deserializing node: " + reader.TokenType);
}
} while (reader.Read());
// don't read if current token is a property. token was already read when parsing element attributes
}
///
/// Checks if the is a namespace attribute.
///
/// Attribute name to test.
/// The attribute name prefix if it has one, otherwise an empty string.
/// true if attribute name is for a namespace attribute, otherwise false.
private bool IsNamespaceAttribute(string attributeName, [NotNullWhen(true)]out string? prefix)
{
if (attributeName.StartsWith("xmlns", StringComparison.Ordinal))
{
if (attributeName.Length == 5)
{
prefix = string.Empty;
return true;
}
else if (attributeName[5] == ':')
{
prefix = attributeName.Substring(6, attributeName.Length - 6);
return true;
}
}
prefix = null;
return false;
}
private bool ValueAttributes(List c)
{
foreach (IXmlNode xmlNode in c)
{
if (xmlNode.NamespaceUri == JsonNamespaceUri)
{
continue;
}
if (xmlNode.NamespaceUri == "http://www.w3.org/2000/xmlns/" && xmlNode.Value == JsonNamespaceUri)
{
continue;
}
return true;
}
return false;
}
#endregion
///
/// Determines whether this instance can convert the specified value type.
///
/// Type of the value.
///
/// true if this instance can convert the specified value type; otherwise, false.
///
public override bool CanConvert(Type valueType)
{
#if HAVE_XLINQ
if (valueType.AssignableToTypeName("System.Xml.Linq.XObject"))
{
return IsXObject(valueType);
}
#endif
#if HAVE_XML_DOCUMENT
if (valueType.AssignableToTypeName("System.Xml.XmlNode"))
{
return IsXmlNode(valueType);
}
#endif
return false;
}
#if HAVE_XLINQ
[MethodImpl(MethodImplOptions.NoInlining)]
private bool IsXObject(Type valueType)
{
return typeof(XObject).IsAssignableFrom(valueType);
}
#endif
#if HAVE_XML_DOCUMENT
[MethodImpl(MethodImplOptions.NoInlining)]
private bool IsXmlNode(Type valueType)
{
return typeof(XmlNode).IsAssignableFrom(valueType);
}
#endif
}
}
#endif
================================================
FILE: Src/Newtonsoft.Json/DateFormatHandling.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
namespace Newtonsoft.Json
{
///
/// Specifies how dates are formatted when writing JSON text.
///
public enum DateFormatHandling
{
///
/// Dates are written in the ISO 8601 format, e.g. "2012-03-21T05:40Z".
///
IsoDateFormat,
///
/// Dates are written in the Microsoft JSON format, e.g. "\/Date(1198908717056)\/".
///
MicrosoftDateFormat
}
}
================================================
FILE: Src/Newtonsoft.Json/DateParseHandling.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
namespace Newtonsoft.Json
{
///
/// Specifies how date formatted strings, e.g. "\/Date(1198908717056)\/" and "2012-03-21T05:40Z", are parsed when reading JSON text.
///
public enum DateParseHandling
{
///
/// Date formatted strings are not parsed to a date type and are read as strings.
///
None = 0,
///
/// Date formatted strings, e.g. "\/Date(1198908717056)\/" and "2012-03-21T05:40Z", are parsed to .
///
DateTime = 1,
#if HAVE_DATE_TIME_OFFSET
///
/// Date formatted strings, e.g. "\/Date(1198908717056)\/" and "2012-03-21T05:40Z", are parsed to .
///
DateTimeOffset = 2
#endif
}
}
================================================
FILE: Src/Newtonsoft.Json/DateTimeZoneHandling.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
namespace Newtonsoft.Json
{
///
/// Specifies how to treat the time value when converting between string and .
///
public enum DateTimeZoneHandling
{
///
/// Treat as local time. If the object represents a Coordinated Universal Time (UTC), it is converted to the local time.
///
Local = 0,
///
/// Treat as a UTC. If the object represents a local time, it is converted to a UTC.
///
Utc = 1,
///
/// Treat as a local time if a is being converted to a string.
/// If a string is being converted to , convert to a local time if a time zone is specified.
///
Unspecified = 2,
///
/// Time zone information should be preserved when converting.
///
RoundtripKind = 3
}
}
================================================
FILE: Src/Newtonsoft.Json/DefaultJsonNameTable.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
using System.Threading;
namespace Newtonsoft.Json
{
///
/// The default JSON name table implementation.
///
public class DefaultJsonNameTable : JsonNameTable
{
// used to defeat hashtable DoS attack where someone passes in lots of strings that hash to the same hash code
private static readonly int HashCodeRandomizer;
private int _count;
private Entry[] _entries;
private int _mask = 31;
static DefaultJsonNameTable()
{
HashCodeRandomizer = Environment.TickCount;
}
///
/// Initializes a new instance of the class.
///
public DefaultJsonNameTable()
{
_entries = new Entry[_mask + 1];
}
///
/// Gets a string containing the same characters as the specified range of characters in the given array.
///
/// The character array containing the name to find.
/// The zero-based index into the array specifying the first character of the name.
/// The number of characters in the name.
/// A string containing the same characters as the specified range of characters in the given array.
public override string? Get(char[] key, int start, int length)
{
if (length == 0)
{
return string.Empty;
}
int hashCode = length + HashCodeRandomizer;
hashCode += (hashCode << 7) ^ key[start];
int end = start + length;
for (int i = start + 1; i < end; i++)
{
hashCode += (hashCode << 7) ^ key[i];
}
hashCode -= hashCode >> 17;
hashCode -= hashCode >> 11;
hashCode -= hashCode >> 5;
// make sure index is evaluated before accessing _entries, otherwise potential race condition causing IndexOutOfRangeException
#if NET20 || NET35 || NET40
int mask = Thread.VolatileRead(ref _mask);
#else
int mask = Volatile.Read(ref _mask);
#endif
var index = hashCode & mask;
var entries = _entries;
for (Entry entry = entries[index]; entry != null; entry = entry.Next)
{
if (entry.HashCode == hashCode && TextEquals(entry.Value, key, start, length))
{
return entry.Value;
}
}
return null;
}
///
/// Adds the specified string into name table.
///
/// The string to add.
/// This method is not thread-safe.
/// The resolved string.
public string Add(string key)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
int length = key.Length;
if (length == 0)
{
return string.Empty;
}
int hashCode = length + HashCodeRandomizer;
for (int i = 0; i < key.Length; i++)
{
hashCode += (hashCode << 7) ^ key[i];
}
hashCode -= hashCode >> 17;
hashCode -= hashCode >> 11;
hashCode -= hashCode >> 5;
for (Entry entry = _entries[hashCode & _mask]; entry != null; entry = entry.Next)
{
if (entry.HashCode == hashCode && entry.Value.Equals(key, StringComparison.Ordinal))
{
return entry.Value;
}
}
return AddEntry(key, hashCode);
}
private string AddEntry(string str, int hashCode)
{
int index = hashCode & _mask;
Entry entry = new Entry(str, hashCode, _entries[index]);
_entries[index] = entry;
if (_count++ == _mask)
{
Grow();
}
return entry.Value;
}
private void Grow()
{
Entry[] entries = _entries;
int newMask = (_mask * 2) + 1;
Entry[] newEntries = new Entry[newMask + 1];
for (int i = 0; i < entries.Length; i++)
{
Entry next;
for (Entry entry = entries[i]; entry != null; entry = next)
{
int index = entry.HashCode & newMask;
next = entry.Next;
entry.Next = newEntries[index];
newEntries[index] = entry;
}
}
_entries = newEntries;
#if NET20 || NET35 || NET40
Thread.VolatileWrite(ref _mask, newMask);
#else
Volatile.Write(ref _mask, newMask);
#endif
}
private static bool TextEquals(string str1, char[] str2, int str2Start, int str2Length)
{
if (str1.Length != str2Length)
{
return false;
}
for (int i = 0; i < str1.Length; i++)
{
if (str1[i] != str2[str2Start + i])
{
return false;
}
}
return true;
}
private class Entry
{
internal readonly string Value;
internal readonly int HashCode;
internal Entry Next;
internal Entry(string value, int hashCode, Entry next)
{
Value = value;
HashCode = hashCode;
Next = next;
}
}
}
}
================================================
FILE: Src/Newtonsoft.Json/DefaultValueHandling.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
using System.ComponentModel;
namespace Newtonsoft.Json
{
///
/// Specifies default value handling options for the .
///
///
///
///
///
[Flags]
public enum DefaultValueHandling
{
///
/// Include members where the member value is the same as the member's default value when serializing objects.
/// Included members are written to JSON. Has no effect when deserializing.
///
Include = 0,
///
/// Ignore members where the member value is the same as the member's default value when serializing objects
/// so that it is not written to JSON.
/// This option will ignore all default values (e.g. null for objects and nullable types; 0 for integers,
/// decimals and floating point numbers; and false for booleans). The default value ignored can be changed by
/// placing the on the property.
///
Ignore = 1,
///
/// Members with a default value but no JSON will be set to their default value when deserializing.
///
Populate = 2,
///
/// Ignore members where the member value is the same as the member's default value when serializing objects
/// and set members to their default value when deserializing.
///
IgnoreAndPopulate = Ignore | Populate
}
}
================================================
FILE: Src/Newtonsoft.Json/FloatFormatHandling.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
namespace Newtonsoft.Json
{
///
/// Specifies float format handling options when writing special floating point numbers, e.g. ,
/// and with .
///
public enum FloatFormatHandling
{
///
/// Write special floating point values as strings in JSON, e.g. "NaN", "Infinity", "-Infinity".
///
String = 0,
///
/// Write special floating point values as symbols in JSON, e.g. NaN, Infinity, -Infinity.
/// Note that this will produce non-valid JSON.
///
Symbol = 1,
///
/// Write special floating point values as the property's default value in JSON, e.g. 0.0 for a property, null for a of property.
///
DefaultValue = 2
}
}
================================================
FILE: Src/Newtonsoft.Json/FloatParseHandling.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
namespace Newtonsoft.Json
{
///
/// Specifies how floating point numbers, e.g. 1.0 and 9.9, are parsed when reading JSON text.
///
public enum FloatParseHandling
{
///
/// Floating point numbers are parsed to .
///
Double = 0,
///
/// Floating point numbers are parsed to .
///
Decimal = 1
}
}
================================================
FILE: Src/Newtonsoft.Json/FormatterAssemblyStyle.cs
================================================
#if HAVE_OBSOLETE_FORMATTER_ASSEMBLY_STYLE
namespace System.Runtime.Serialization.Formatters
{
///
/// Indicates the method that will be used during deserialization for locating and loading assemblies.
///
[Obsolete("FormatterAssemblyStyle is obsolete. Use TypeNameAssemblyFormatHandling instead.")]
public enum FormatterAssemblyStyle
{
///
/// In simple mode, the assembly used during deserialization need not match exactly the assembly used during serialization. Specifically, the version numbers need not match as the method is used to load the assembly.
///
Simple = 0,
///
/// In full mode, the assembly used during deserialization must match exactly the assembly used during serialization. The is used to load the assembly.
///
Full = 1
}
}
#endif
================================================
FILE: Src/Newtonsoft.Json/Formatting.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
namespace Newtonsoft.Json
{
///
/// Specifies formatting options for the .
///
public enum Formatting
{
///
/// No special formatting is applied. This is the default.
///
None = 0,
///
/// Causes child objects to be indented according to the and settings.
///
Indented = 1
}
}
================================================
FILE: Src/Newtonsoft.Json/IArrayPool.cs
================================================
namespace Newtonsoft.Json
{
///
/// Provides an interface for using pooled arrays.
///
/// The array type content.
public interface IArrayPool
{
///
/// Rent an array from the pool. This array must be returned when it is no longer needed.
///
/// The minimum required length of the array. The returned array may be longer.
/// The rented array from the pool. This array must be returned when it is no longer needed.
T[] Rent(int minimumLength);
///
/// Return an array to the pool.
///
/// The array that is being returned.
void Return(T[]? array);
}
}
================================================
FILE: Src/Newtonsoft.Json/IJsonLineInfo.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
namespace Newtonsoft.Json
{
///
/// Provides an interface to enable a class to return line and position information.
///
public interface IJsonLineInfo
{
///
/// Gets a value indicating whether the class can return line information.
///
///
/// true if and can be provided; otherwise, false.
///
bool HasLineInfo();
///
/// Gets the current line number.
///
/// The current line number or 0 if no line information is available (for example, when returns false).
int LineNumber { get; }
///
/// Gets the current line position.
///
/// The current line position or 0 if no line information is available (for example, when returns false).
int LinePosition { get; }
}
}
================================================
FILE: Src/Newtonsoft.Json/JsonArrayAttribute.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
namespace Newtonsoft.Json
{
///
/// Instructs the how to serialize the collection.
///
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = false)]
public sealed class JsonArrayAttribute : JsonContainerAttribute
{
private bool _allowNullItems;
///
/// Gets or sets a value indicating whether null items are allowed in the collection.
///
/// true if null items are allowed in the collection; otherwise, false.
public bool AllowNullItems
{
get => _allowNullItems;
set => _allowNullItems = value;
}
///
/// Initializes a new instance of the class.
///
public JsonArrayAttribute()
{
}
///
/// Initializes a new instance of the class with a flag indicating whether the array can contain null items.
///
/// A flag indicating whether the array can contain null items.
public JsonArrayAttribute(bool allowNullItems)
{
_allowNullItems = allowNullItems;
}
///
/// Initializes a new instance of the class with the specified container Id.
///
/// The container Id.
public JsonArrayAttribute(string id)
: base(id)
{
}
}
}
================================================
FILE: Src/Newtonsoft.Json/JsonConstructorAttribute.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
namespace Newtonsoft.Json
{
///
/// Instructs the to use the specified constructor when deserializing that object.
///
[AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false)]
public sealed class JsonConstructorAttribute : Attribute
{
}
}
================================================
FILE: Src/Newtonsoft.Json/JsonContainerAttribute.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
using Newtonsoft.Json.Serialization;
namespace Newtonsoft.Json
{
///
/// Instructs the how to serialize the object.
///
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = false)]
public abstract class JsonContainerAttribute : Attribute
{
///
/// Gets or sets the id.
///
/// The id.
public string? Id { get; set; }
///
/// Gets or sets the title.
///
/// The title.
public string? Title { get; set; }
///
/// Gets or sets the description.
///
/// The description.
public string? Description { get; set; }
///
/// Gets or sets the collection's items converter.
///
/// The collection's items converter.
public Type? ItemConverterType { get; set; }
///
/// The parameter list to use when constructing the described by .
/// If null, the default constructor is used.
/// When non-null, there must be a constructor defined in the that exactly matches the number,
/// order, and type of these parameters.
///
///
///
/// [JsonContainer(ItemConverterType = typeof(MyContainerConverter), ItemConverterParameters = new object[] { 123, "Four" })]
///
///
public object[]? ItemConverterParameters { get; set; }
///
/// Gets or sets the of the .
///
/// The of the .
public Type? NamingStrategyType
{
get => _namingStrategyType;
set
{
_namingStrategyType = value;
NamingStrategyInstance = null;
}
}
///
/// The parameter list to use when constructing the described by .
/// If null, the default constructor is used.
/// When non-null, there must be a constructor defined in the that exactly matches the number,
/// order, and type of these parameters.
///
///
///
/// [JsonContainer(NamingStrategyType = typeof(MyNamingStrategy), NamingStrategyParameters = new object[] { 123, "Four" })]
///
///
public object[]? NamingStrategyParameters
{
get => _namingStrategyParameters;
set
{
_namingStrategyParameters = value;
NamingStrategyInstance = null;
}
}
internal NamingStrategy? NamingStrategyInstance { get; set; }
// yuck. can't set nullable properties on an attribute in C#
// have to use this approach to get an unset default state
internal bool? _isReference;
internal bool? _itemIsReference;
internal ReferenceLoopHandling? _itemReferenceLoopHandling;
internal TypeNameHandling? _itemTypeNameHandling;
private Type? _namingStrategyType;
private object[]? _namingStrategyParameters;
///
/// Gets or sets a value that indicates whether to preserve object references.
///
///
/// true to keep object reference; otherwise, false. The default is false.
///
public bool IsReference
{
get => _isReference ?? default;
set => _isReference = value;
}
///
/// Gets or sets a value that indicates whether to preserve collection's items references.
///
///
/// true to keep collection's items object references; otherwise, false. The default is false.
///
public bool ItemIsReference
{
get => _itemIsReference ?? default;
set => _itemIsReference = value;
}
///
/// Gets or sets the reference loop handling used when serializing the collection's items.
///
/// The reference loop handling.
public ReferenceLoopHandling ItemReferenceLoopHandling
{
get => _itemReferenceLoopHandling ?? default;
set => _itemReferenceLoopHandling = value;
}
///
/// Gets or sets the type name handling used when serializing the collection's items.
///
/// The type name handling.
public TypeNameHandling ItemTypeNameHandling
{
get => _itemTypeNameHandling ?? default;
set => _itemTypeNameHandling = value;
}
///
/// Initializes a new instance of the class.
///
protected JsonContainerAttribute()
{
}
///
/// Initializes a new instance of the class with the specified container Id.
///
/// The container Id.
protected JsonContainerAttribute(string id)
{
Id = id;
}
}
}
================================================
FILE: Src/Newtonsoft.Json/JsonConvert.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
using System.IO;
using System.Globalization;
#if HAVE_BIG_INTEGER
using System.Numerics;
#endif
using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Utilities;
using System.Xml;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Serialization;
using System.Text;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Diagnostics.CodeAnalysis;
#if HAVE_XLINQ
using System.Xml.Linq;
#endif
namespace Newtonsoft.Json
{
///
/// Provides methods for converting between .NET types and JSON types.
///
///
///
///
public static class JsonConvert
{
///
/// Gets or sets a function that creates default .
/// Default settings are automatically used by serialization methods on ,
/// and and on .
/// To serialize without using any default settings create a with
/// .
///
public static Func? DefaultSettings { get; set; }
///
/// Represents JavaScript's boolean value true as a string. This field is read-only.
///
public static readonly string True = "true";
///
/// Represents JavaScript's boolean value false as a string. This field is read-only.
///
public static readonly string False = "false";
///
/// Represents JavaScript's null as a string. This field is read-only.
///
public static readonly string Null = "null";
///
/// Represents JavaScript's undefined as a string. This field is read-only.
///
public static readonly string Undefined = "undefined";
///
/// Represents JavaScript's positive infinity as a string. This field is read-only.
///
public static readonly string PositiveInfinity = "Infinity";
///
/// Represents JavaScript's negative infinity as a string. This field is read-only.
///
public static readonly string NegativeInfinity = "-Infinity";
///
/// Represents JavaScript's NaN as a string. This field is read-only.
///
public static readonly string NaN = "NaN";
///
/// Converts the to its JSON string representation.
///
/// The value to convert.
/// A JSON string representation of the .
public static string ToString(DateTime value)
{
return ToString(value, DateFormatHandling.IsoDateFormat, DateTimeZoneHandling.RoundtripKind);
}
///
/// Converts the to its JSON string representation using the specified.
///
/// The value to convert.
/// The format the date will be converted to.
/// The time zone handling when the date is converted to a string.
/// A JSON string representation of the .
public static string ToString(DateTime value, DateFormatHandling format, DateTimeZoneHandling timeZoneHandling)
{
DateTime updatedDateTime = DateTimeUtils.EnsureDateTime(value, timeZoneHandling);
using (StringWriter writer = StringUtils.CreateStringWriter(64))
{
writer.Write('"');
DateTimeUtils.WriteDateTimeString(writer, updatedDateTime, format, null, CultureInfo.InvariantCulture);
writer.Write('"');
return writer.ToString();
}
}
#if HAVE_DATE_TIME_OFFSET
///
/// Converts the to its JSON string representation.
///
/// The value to convert.
/// A JSON string representation of the .
public static string ToString(DateTimeOffset value)
{
return ToString(value, DateFormatHandling.IsoDateFormat);
}
///
/// Converts the to its JSON string representation using the specified.
///
/// The value to convert.
/// The format the date will be converted to.
/// A JSON string representation of the .
public static string ToString(DateTimeOffset value, DateFormatHandling format)
{
using (StringWriter writer = StringUtils.CreateStringWriter(64))
{
writer.Write('"');
DateTimeUtils.WriteDateTimeOffsetString(writer, value, format, null, CultureInfo.InvariantCulture);
writer.Write('"');
return writer.ToString();
}
}
#endif
///
/// Converts the to its JSON string representation.
///
/// The value to convert.
/// A JSON string representation of the .
public static string ToString(bool value)
{
return (value) ? True : False;
}
///
/// Converts the to its JSON string representation.
///
/// The value to convert.
/// A JSON string representation of the .
public static string ToString(char value)
{
return ToString(char.ToString(value));
}
///
/// Converts the to its JSON string representation.
///
/// The value to convert.
/// A JSON string representation of the .
public static string ToString(Enum value)
{
return value.ToString("D");
}
///
/// Converts the to its JSON string representation.
///
/// The value to convert.
/// A JSON string representation of the .
public static string ToString(int value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
///
/// Converts the to its JSON string representation.
///
/// The value to convert.
/// A JSON string representation of the .
public static string ToString(short value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
///
/// Converts the to its JSON string representation.
///
/// The value to convert.
/// A JSON string representation of the .
[CLSCompliant(false)]
public static string ToString(ushort value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
///
/// Converts the to its JSON string representation.
///
/// The value to convert.
/// A JSON string representation of the .
[CLSCompliant(false)]
public static string ToString(uint value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
///
/// Converts the to its JSON string representation.
///
/// The value to convert.
/// A JSON string representation of the .
public static string ToString(long value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
#if HAVE_BIG_INTEGER
private static string ToStringInternal(BigInteger value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
#endif
///
/// Converts the to its JSON string representation.
///
/// The value to convert.
/// A JSON string representation of the .
[CLSCompliant(false)]
public static string ToString(ulong value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
///
/// Converts the to its JSON string representation.
///
/// The value to convert.
/// A JSON string representation of the .
public static string ToString(float value)
{
return EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture));
}
internal static string ToString(float value, FloatFormatHandling floatFormatHandling, char quoteChar, bool nullable)
{
return EnsureFloatFormat(value, EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture)), floatFormatHandling, quoteChar, nullable);
}
private static string EnsureFloatFormat(double value, string text, FloatFormatHandling floatFormatHandling, char quoteChar, bool nullable)
{
if (floatFormatHandling == FloatFormatHandling.Symbol || !(double.IsInfinity(value) || double.IsNaN(value)))
{
return text;
}
if (floatFormatHandling == FloatFormatHandling.DefaultValue)
{
return (!nullable) ? "0.0" : Null;
}
return quoteChar + text + quoteChar;
}
///
/// Converts the to its JSON string representation.
///
/// The value to convert.
/// A JSON string representation of the .
public static string ToString(double value)
{
return EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture));
}
internal static string ToString(double value, FloatFormatHandling floatFormatHandling, char quoteChar, bool nullable)
{
return EnsureFloatFormat(value, EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture)), floatFormatHandling, quoteChar, nullable);
}
private static string EnsureDecimalPlace(double value, string text)
{
if (double.IsNaN(value) || double.IsInfinity(value) || StringUtils.IndexOf(text, '.') != -1 || StringUtils.IndexOf(text, 'E') != -1 || StringUtils.IndexOf(text, 'e') != -1)
{
return text;
}
return text + ".0";
}
private static string EnsureDecimalPlace(string text)
{
if (StringUtils.IndexOf(text, '.') != -1)
{
return text;
}
return text + ".0";
}
///
/// Converts the to its JSON string representation.
///
/// The value to convert.
/// A JSON string representation of the .
public static string ToString(byte value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
///
/// Converts the to its JSON string representation.
///
/// The value to convert.
/// A JSON string representation of the .
[CLSCompliant(false)]
public static string ToString(sbyte value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
///
/// Converts the to its JSON string representation.
///
/// The value to convert.
/// A JSON string representation of the .
public static string ToString(decimal value)
{
return EnsureDecimalPlace(value.ToString(null, CultureInfo.InvariantCulture));
}
///
/// Converts the to its JSON string representation.
///
/// The value to convert.
/// A JSON string representation of the .
public static string ToString(Guid value)
{
return ToString(value, '"');
}
internal static string ToString(Guid value, char quoteChar)
{
string text;
string qc;
#if HAVE_CHAR_TO_STRING_WITH_CULTURE
text = value.ToString("D", CultureInfo.InvariantCulture);
qc = quoteChar.ToString(CultureInfo.InvariantCulture);
#else
text = value.ToString("D");
qc = quoteChar.ToString();
#endif
return qc + text + qc;
}
///
/// Converts the to its JSON string representation.
///
/// The value to convert.
/// A JSON string representation of the .
public static string ToString(TimeSpan value)
{
return ToString(value, '"');
}
internal static string ToString(TimeSpan value, char quoteChar)
{
return ToString(value.ToString(), quoteChar);
}
///
/// Converts the to its JSON string representation.
///
/// The value to convert.
/// A JSON string representation of the .
public static string ToString(Uri? value)
{
if (value == null)
{
return Null;
}
return ToString(value, '"');
}
internal static string ToString(Uri value, char quoteChar)
{
return ToString(value.OriginalString, quoteChar);
}
///
/// Converts the to its JSON string representation.
///
/// The value to convert.
/// A JSON string representation of the .
public static string ToString(string? value)
{
return ToString(value, '"');
}
///
/// Converts the to its JSON string representation.
///
/// The value to convert.
/// The string delimiter character.
/// A JSON string representation of the .
public static string ToString(string? value, char delimiter)
{
return ToString(value, delimiter, StringEscapeHandling.Default);
}
///
/// Converts the to its JSON string representation.
///
/// The value to convert.
/// The string delimiter character.
/// The string escape handling.
/// A JSON string representation of the .
public static string ToString(string? value, char delimiter, StringEscapeHandling stringEscapeHandling)
{
if (delimiter != '"' && delimiter != '\'')
{
throw new ArgumentException("Delimiter must be a single or double quote.", nameof(delimiter));
}
return JavaScriptUtils.ToEscapedJavaScriptString(value, delimiter, true, stringEscapeHandling);
}
///
/// Converts the to its JSON string representation.
///
/// The value to convert.
/// A JSON string representation of the .
public static string ToString(object? value)
{
if (value == null)
{
return Null;
}
PrimitiveTypeCode typeCode = ConvertUtils.GetTypeCode(value.GetType());
switch (typeCode)
{
case PrimitiveTypeCode.String:
return ToString((string)value);
case PrimitiveTypeCode.Char:
return ToString((char)value);
case PrimitiveTypeCode.Boolean:
return ToString((bool)value);
case PrimitiveTypeCode.SByte:
return ToString((sbyte)value);
case PrimitiveTypeCode.Int16:
return ToString((short)value);
case PrimitiveTypeCode.UInt16:
return ToString((ushort)value);
case PrimitiveTypeCode.Int32:
return ToString((int)value);
case PrimitiveTypeCode.Byte:
return ToString((byte)value);
case PrimitiveTypeCode.UInt32:
return ToString((uint)value);
case PrimitiveTypeCode.Int64:
return ToString((long)value);
case PrimitiveTypeCode.UInt64:
return ToString((ulong)value);
case PrimitiveTypeCode.Single:
return ToString((float)value);
case PrimitiveTypeCode.Double:
return ToString((double)value);
case PrimitiveTypeCode.DateTime:
return ToString((DateTime)value);
case PrimitiveTypeCode.Decimal:
return ToString((decimal)value);
#if HAVE_DB_NULL_TYPE_CODE
case PrimitiveTypeCode.DBNull:
return Null;
#endif
#if HAVE_DATE_TIME_OFFSET
case PrimitiveTypeCode.DateTimeOffset:
return ToString((DateTimeOffset)value);
#endif
case PrimitiveTypeCode.Guid:
return ToString((Guid)value);
case PrimitiveTypeCode.Uri:
return ToString((Uri)value);
case PrimitiveTypeCode.TimeSpan:
return ToString((TimeSpan)value);
#if HAVE_BIG_INTEGER
case PrimitiveTypeCode.BigInteger:
return ToStringInternal((BigInteger)value);
#endif
}
throw new ArgumentException("Unsupported type: {0}. Use the JsonSerializer class to get the object's JSON representation.".FormatWith(CultureInfo.InvariantCulture, value.GetType()));
}
#region Serialize
///
/// Serializes the specified object to a JSON string.
///
/// The object to serialize.
/// A JSON string representation of the object.
[DebuggerStepThrough]
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public static string SerializeObject(object? value)
{
return SerializeObject(value, null, (JsonSerializerSettings?)null);
}
///
/// Serializes the specified object to a JSON string using formatting.
///
/// The object to serialize.
/// Indicates how the output should be formatted.
///
/// A JSON string representation of the object.
///
[DebuggerStepThrough]
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public static string SerializeObject(object? value, Formatting formatting)
{
return SerializeObject(value, formatting, (JsonSerializerSettings?)null);
}
///
/// Serializes the specified object to a JSON string using a collection of .
///
/// The object to serialize.
/// A collection of converters used while serializing.
/// A JSON string representation of the object.
[DebuggerStepThrough]
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public static string SerializeObject(object? value, params JsonConverter[] converters)
{
JsonSerializerSettings? settings = (converters != null && converters.Length > 0)
? new JsonSerializerSettings { Converters = converters }
: null;
return SerializeObject(value, null, settings);
}
///
/// Serializes the specified object to a JSON string using formatting and a collection of .
///
/// The object to serialize.
/// Indicates how the output should be formatted.
/// A collection of converters used while serializing.
/// A JSON string representation of the object.
[DebuggerStepThrough]
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public static string SerializeObject(object? value, Formatting formatting, params JsonConverter[] converters)
{
JsonSerializerSettings? settings = (converters != null && converters.Length > 0)
? new JsonSerializerSettings { Converters = converters }
: null;
return SerializeObject(value, null, formatting, settings);
}
///
/// Serializes the specified object to a JSON string using .
///
/// The object to serialize.
/// The used to serialize the object.
/// If this is null, default serialization settings will be used.
///
/// A JSON string representation of the object.
///
[DebuggerStepThrough]
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public static string SerializeObject(object? value, JsonSerializerSettings? settings)
{
return SerializeObject(value, null, settings);
}
///
/// Serializes the specified object to a JSON string using a type and .
///
/// The object to serialize.
/// The used to serialize the object.
/// If this is null, default serialization settings will be used.
///
/// The type of the value being serialized.
/// This parameter is used when is to write out the type name if the type of the value does not match.
/// Specifying the type is optional.
///
///
/// A JSON string representation of the object.
///
[DebuggerStepThrough]
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public static string SerializeObject(object? value, Type? type, JsonSerializerSettings? settings)
{
JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings);
return SerializeObjectInternal(value, type, jsonSerializer);
}
///
/// Serializes the specified object to a JSON string using formatting and .
///
/// The object to serialize.
/// Indicates how the output should be formatted. This value overrides the formatting specified on .
/// The used to serialize the object.
/// If this is null, default serialization settings will be used.
///
/// A JSON string representation of the object.
///
[DebuggerStepThrough]
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public static string SerializeObject(object? value, Formatting formatting, JsonSerializerSettings? settings)
{
return SerializeObject(value, null, formatting, settings);
}
///
/// Serializes the specified object to a JSON string using a type, formatting and .
///
/// The object to serialize.
/// Indicates how the output should be formatted. This value overrides the formatting specified on .
/// The used to serialize the object.
/// If this is null, default serialization settings will be used.
///
/// The type of the value being serialized.
/// This parameter is used when is to write out the type name if the type of the value does not match.
/// Specifying the type is optional.
///
///
/// A JSON string representation of the object.
///
[DebuggerStepThrough]
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public static string SerializeObject(object? value, Type? type, Formatting formatting, JsonSerializerSettings? settings)
{
JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings);
jsonSerializer.Formatting = formatting;
return SerializeObjectInternal(value, type, jsonSerializer);
}
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
private static string SerializeObjectInternal(object? value, Type? type, JsonSerializer jsonSerializer)
{
StringBuilder sb = new StringBuilder(256);
StringWriter sw = new StringWriter(sb, CultureInfo.InvariantCulture);
using (JsonTextWriter jsonWriter = new JsonTextWriter(sw))
{
jsonWriter.Formatting = jsonSerializer.Formatting;
jsonSerializer.Serialize(jsonWriter, value, type);
}
return sw.ToString();
}
#endregion
#region Deserialize
///
/// Deserializes the JSON to a .NET object.
///
/// The JSON to deserialize.
/// The deserialized object from the JSON string. A value is returned if the provided JSON is valid but represents a null value.
[DebuggerStepThrough]
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public static object? DeserializeObject(string value)
{
return DeserializeObject(value, null, (JsonSerializerSettings?)null);
}
///
/// Deserializes the JSON to a .NET object using .
///
/// The JSON to deserialize.
///
/// The used to deserialize the object.
/// If this is null, default serialization settings will be used.
///
/// The deserialized object from the JSON string. A value is returned if the provided JSON is valid but represents a null value.
[DebuggerStepThrough]
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public static object? DeserializeObject(string value, JsonSerializerSettings settings)
{
return DeserializeObject(value, null, settings);
}
///
/// Deserializes the JSON to the specified .NET type.
///
/// The JSON to deserialize.
/// The of object being deserialized.
/// The deserialized object from the JSON string. A value is returned if the provided JSON is valid but represents a null value.
[DebuggerStepThrough]
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public static object? DeserializeObject(string value, Type type)
{
return DeserializeObject(value, type, (JsonSerializerSettings?)null);
}
///
/// Deserializes the JSON to the specified .NET type.
///
/// The type of the object to deserialize to.
/// The JSON to deserialize.
/// The deserialized object from the JSON string. A value is returned if the provided JSON is valid but represents a null value.
[DebuggerStepThrough]
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public static T? DeserializeObject(string value)
{
return DeserializeObject(value, (JsonSerializerSettings?)null);
}
///
/// Deserializes the JSON to the given anonymous type.
///
///
/// The anonymous type to deserialize to. This can't be specified
/// traditionally and must be inferred from the anonymous type passed
/// as a parameter.
///
/// The JSON to deserialize.
/// The anonymous type object.
/// The deserialized anonymous type from the JSON string. A value is returned if the provided JSON is valid but represents a null value.
[DebuggerStepThrough]
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public static T? DeserializeAnonymousType(string value, T anonymousTypeObject)
{
return DeserializeObject(value);
}
///
/// Deserializes the JSON to the given anonymous type using .
///
///
/// The anonymous type to deserialize to. This can't be specified
/// traditionally and must be inferred from the anonymous type passed
/// as a parameter.
///
/// The JSON to deserialize.
/// The anonymous type object.
///
/// The used to deserialize the object.
/// If this is null, default serialization settings will be used.
///
/// The deserialized anonymous type from the JSON string. A value is returned if the provided JSON is valid but represents a null value.
[DebuggerStepThrough]
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public static T? DeserializeAnonymousType(string value, T anonymousTypeObject, JsonSerializerSettings settings)
{
return DeserializeObject(value, settings);
}
///
/// Deserializes the JSON to the specified .NET type using a collection of .
///
/// The type of the object to deserialize to.
/// The JSON to deserialize.
/// Converters to use while deserializing.
/// The deserialized object from the JSON string. A value is returned if the provided JSON is valid but represents a null value.
[DebuggerStepThrough]
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public static T? DeserializeObject(string value, params JsonConverter[] converters)
{
return (T?)DeserializeObject(value, typeof(T), converters);
}
///
/// Deserializes the JSON to the specified .NET type using .
///
/// The type of the object to deserialize to.
/// The object to deserialize.
///
/// The used to deserialize the object.
/// If this is null, default serialization settings will be used.
///
/// The deserialized object from the JSON string. A value is returned if the provided JSON is valid but represents a null value.
[DebuggerStepThrough]
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public static T? DeserializeObject(string value, JsonSerializerSettings? settings)
{
return (T?)DeserializeObject(value, typeof(T), settings);
}
///
/// Deserializes the JSON to the specified .NET type using a collection of .
///
/// The JSON to deserialize.
/// The type of the object to deserialize.
/// Converters to use while deserializing.
/// The deserialized object from the JSON string. A value is returned if the provided JSON is valid but represents a null value.
[DebuggerStepThrough]
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public static object? DeserializeObject(string value, Type type, params JsonConverter[] converters)
{
JsonSerializerSettings? settings = (converters != null && converters.Length > 0)
? new JsonSerializerSettings { Converters = converters }
: null;
return DeserializeObject(value, type, settings);
}
///
/// Deserializes the JSON to the specified .NET type using .
///
/// The JSON to deserialize.
/// The type of the object to deserialize to.
///
/// The used to deserialize the object.
/// If this is null, default serialization settings will be used.
///
/// The deserialized object from the JSON string. A value is returned if the provided JSON is valid but represents a null value.
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public static object? DeserializeObject(string value, Type? type, JsonSerializerSettings? settings)
{
ValidationUtils.ArgumentNotNull(value, nameof(value));
JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings);
// by default DeserializeObject should check for additional content
if (!jsonSerializer.IsCheckAdditionalContentSet())
{
jsonSerializer.CheckAdditionalContent = true;
}
using (JsonTextReader reader = new JsonTextReader(new StringReader(value)))
{
return jsonSerializer.Deserialize(reader, type);
}
}
#endregion
#region Populate
///
/// Populates the object with values from the JSON string.
///
/// The JSON to populate values from.
/// The target object to populate values onto.
[DebuggerStepThrough]
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public static void PopulateObject(string value, object target)
{
PopulateObject(value, target, null);
}
///
/// Populates the object with values from the JSON string using .
///
/// The JSON to populate values from.
/// The target object to populate values onto.
///
/// The used to deserialize the object.
/// If this is null, default serialization settings will be used.
///
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public static void PopulateObject(string value, object target, JsonSerializerSettings? settings)
{
JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings);
using (JsonReader jsonReader = new JsonTextReader(new StringReader(value)))
{
jsonSerializer.Populate(jsonReader, target);
if (settings != null && settings.CheckAdditionalContent)
{
while (jsonReader.Read())
{
if (jsonReader.TokenType != JsonToken.Comment)
{
throw JsonSerializationException.Create(jsonReader, "Additional text found in JSON string after finishing deserializing object.");
}
}
}
}
}
#endregion
#region Xml
#if HAVE_XML_DOCUMENT
///
/// Serializes the to a JSON string.
///
/// The node to serialize.
/// A JSON string of the .
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public static string SerializeXmlNode(XmlNode? node)
{
return SerializeXmlNode(node, Formatting.None);
}
///
/// Serializes the to a JSON string using formatting.
///
/// The node to serialize.
/// Indicates how the output should be formatted.
/// A JSON string of the .
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public static string SerializeXmlNode(XmlNode? node, Formatting formatting)
{
XmlNodeConverter converter = new XmlNodeConverter();
return SerializeObject(node, formatting, converter);
}
///
/// Serializes the to a JSON string using formatting and omits the root object if is true.
///
/// The node to serialize.
/// Indicates how the output should be formatted.
/// Omits writing the root object.
/// A JSON string of the .
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public static string SerializeXmlNode(XmlNode? node, Formatting formatting, bool omitRootObject)
{
XmlNodeConverter converter = new XmlNodeConverter { OmitRootObject = omitRootObject };
return SerializeObject(node, formatting, converter);
}
///
/// Deserializes the from a JSON string.
///
/// The JSON string.
/// The deserialized .
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public static XmlDocument? DeserializeXmlNode(string value)
{
return DeserializeXmlNode(value, null);
}
///
/// Deserializes the from a JSON string nested in a root element specified by .
///
/// The JSON string.
/// The name of the root element to append when deserializing.
/// The deserialized .
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public static XmlDocument? DeserializeXmlNode(string value, string? deserializeRootElementName)
{
return DeserializeXmlNode(value, deserializeRootElementName, false);
}
///
/// Deserializes the from a JSON string nested in a root element specified by
/// and writes a Json.NET array attribute for collections.
///
/// The JSON string.
/// The name of the root element to append when deserializing.
///
/// A value to indicate whether to write the Json.NET array attribute.
/// This attribute helps preserve arrays when converting the written XML back to JSON.
///
/// The deserialized .
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public static XmlDocument? DeserializeXmlNode(string value, string? deserializeRootElementName, bool writeArrayAttribute)
{
return DeserializeXmlNode(value, deserializeRootElementName, writeArrayAttribute, false);
}
///
/// Deserializes the from a JSON string nested in a root element specified by ,
/// writes a Json.NET array attribute for collections, and encodes special characters.
///
/// The JSON string.
/// The name of the root element to append when deserializing.
///
/// A value to indicate whether to write the Json.NET array attribute.
/// This attribute helps preserve arrays when converting the written XML back to JSON.
///
///
/// A value to indicate whether to encode special characters when converting JSON to XML.
/// If true, special characters like ':', '@', '?', '#' and '$' in JSON property names aren't used to specify
/// XML namespaces, attributes or processing directives. Instead special characters are encoded and written
/// as part of the XML element name.
///
/// The deserialized .
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public static XmlDocument? DeserializeXmlNode(string value, string? deserializeRootElementName, bool writeArrayAttribute, bool encodeSpecialCharacters)
{
XmlNodeConverter converter = new XmlNodeConverter();
converter.DeserializeRootElementName = deserializeRootElementName;
converter.WriteArrayAttribute = writeArrayAttribute;
converter.EncodeSpecialCharacters = encodeSpecialCharacters;
return (XmlDocument?)DeserializeObject(value, typeof(XmlDocument), converter);
}
#endif
#if HAVE_XLINQ
///
/// Serializes the to a JSON string.
///
/// The node to convert to JSON.
/// A JSON string of the .
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public static string SerializeXNode(XObject? node)
{
return SerializeXNode(node, Formatting.None);
}
///
/// Serializes the to a JSON string using formatting.
///
/// The node to convert to JSON.
/// Indicates how the output should be formatted.
/// A JSON string of the .
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public static string SerializeXNode(XObject? node, Formatting formatting)
{
return SerializeXNode(node, formatting, false);
}
///
/// Serializes the to a JSON string using formatting and omits the root object if is true.
///
/// The node to serialize.
/// Indicates how the output should be formatted.
/// Omits writing the root object.
/// A JSON string of the .
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public static string SerializeXNode(XObject? node, Formatting formatting, bool omitRootObject)
{
XmlNodeConverter converter = new XmlNodeConverter { OmitRootObject = omitRootObject };
return SerializeObject(node, formatting, converter);
}
///
/// Deserializes the from a JSON string.
///
/// The JSON string.
/// The deserialized .
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public static XDocument? DeserializeXNode(string value)
{
return DeserializeXNode(value, null);
}
///
/// Deserializes the from a JSON string nested in a root element specified by .
///
/// The JSON string.
/// The name of the root element to append when deserializing.
/// The deserialized .
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public static XDocument? DeserializeXNode(string value, string? deserializeRootElementName)
{
return DeserializeXNode(value, deserializeRootElementName, false);
}
///
/// Deserializes the from a JSON string nested in a root element specified by
/// and writes a Json.NET array attribute for collections.
///
/// The JSON string.
/// The name of the root element to append when deserializing.
///
/// A value to indicate whether to write the Json.NET array attribute.
/// This attribute helps preserve arrays when converting the written XML back to JSON.
///
/// The deserialized .
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public static XDocument? DeserializeXNode(string value, string? deserializeRootElementName, bool writeArrayAttribute)
{
return DeserializeXNode(value, deserializeRootElementName, writeArrayAttribute, false);
}
///
/// Deserializes the from a JSON string nested in a root element specified by ,
/// writes a Json.NET array attribute for collections, and encodes special characters.
///
/// The JSON string.
/// The name of the root element to append when deserializing.
///
/// A value to indicate whether to write the Json.NET array attribute.
/// This attribute helps preserve arrays when converting the written XML back to JSON.
///
///
/// A value to indicate whether to encode special characters when converting JSON to XML.
/// If true, special characters like ':', '@', '?', '#' and '$' in JSON property names aren't used to specify
/// XML namespaces, attributes or processing directives. Instead special characters are encoded and written
/// as part of the XML element name.
///
/// The deserialized .
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public static XDocument? DeserializeXNode(string value, string? deserializeRootElementName, bool writeArrayAttribute, bool encodeSpecialCharacters)
{
XmlNodeConverter converter = new XmlNodeConverter();
converter.DeserializeRootElementName = deserializeRootElementName;
converter.WriteArrayAttribute = writeArrayAttribute;
converter.EncodeSpecialCharacters = encodeSpecialCharacters;
return (XDocument?)DeserializeObject(value, typeof(XDocument), converter);
}
#endif
#endregion
}
}
================================================
FILE: Src/Newtonsoft.Json/JsonConverter.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
using Newtonsoft.Json.Utilities;
using System.Globalization;
using System.Runtime.CompilerServices;
using System.Diagnostics.CodeAnalysis;
namespace Newtonsoft.Json
{
///
/// Converts an object to and from JSON.
///
public abstract class JsonConverter
{
///
/// Writes the JSON representation of the object.
///
/// The to write to.
/// The value.
/// The calling serializer.
public abstract void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer);
///
/// Reads the JSON representation of the object.
///
/// The to read from.
/// Type of the object.
/// The existing value of object being read.
/// The calling serializer.
/// The object value.
public abstract object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer);
///
/// Determines whether this instance can convert the specified object type.
///
/// Type of the object.
///
/// true if this instance can convert the specified object type; otherwise, false.
///
public abstract bool CanConvert(Type objectType);
///
/// Gets a value indicating whether this can read JSON.
///
/// true if this can read JSON; otherwise, false.
public virtual bool CanRead => true;
///
/// Gets a value indicating whether this can write JSON.
///
/// true if this can write JSON; otherwise, false.
public virtual bool CanWrite => true;
}
///
/// Converts an object to and from JSON.
///
/// The object type to convert.
public abstract class JsonConverter : JsonConverter
{
///
/// Writes the JSON representation of the object.
///
/// The to write to.
/// The value.
/// The calling serializer.
public sealed override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
{
if (!(value != null ? value is T : ReflectionUtils.IsNullable(typeof(T))))
{
throw new JsonSerializationException("Converter cannot write specified value to JSON. {0} is required.".FormatWith(CultureInfo.InvariantCulture, typeof(T)));
}
WriteJson(writer, (T?)value, serializer);
}
///
/// Writes the JSON representation of the object.
///
/// The to write to.
/// The value.
/// The calling serializer.
public abstract void WriteJson(JsonWriter writer, T? value, JsonSerializer serializer);
///
/// Reads the JSON representation of the object.
///
/// The to read from.
/// Type of the object.
/// The existing value of object being read.
/// The calling serializer.
/// The object value.
public sealed override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
{
bool existingIsNull = existingValue == null;
if (!(existingIsNull || existingValue is T))
{
throw new JsonSerializationException("Converter cannot read JSON with the specified existing value. {0} is required.".FormatWith(CultureInfo.InvariantCulture, typeof(T)));
}
return ReadJson(reader, objectType, existingIsNull ? default : (T?)existingValue, !existingIsNull, serializer);
}
///
/// Reads the JSON representation of the object.
///
/// The to read from.
/// Type of the object.
/// The existing value of object being read. If there is no existing value then null will be used.
/// The existing value has a value.
/// The calling serializer.
/// The object value.
public abstract T? ReadJson(JsonReader reader, Type objectType, T? existingValue, bool hasExistingValue, JsonSerializer serializer);
///
/// Determines whether this instance can convert the specified object type.
///
/// Type of the object.
///
/// true if this instance can convert the specified object type; otherwise, false.
///
public sealed override bool CanConvert(Type objectType)
{
return typeof(T).IsAssignableFrom(objectType);
}
}
}
================================================
FILE: Src/Newtonsoft.Json/JsonConverterAttribute.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
using Newtonsoft.Json.Utilities;
using System.Globalization;
namespace Newtonsoft.Json
{
///
/// Instructs the to use the specified when serializing the member or class.
///
[AttributeUsage(AttributeTargets.Field | AttributeTargets.Property | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface | AttributeTargets.Enum | AttributeTargets.Parameter, AllowMultiple = false)]
public sealed class JsonConverterAttribute : Attribute
{
private readonly Type _converterType;
///
/// Gets the of the .
///
/// The of the .
public Type ConverterType => _converterType;
///
/// The parameter list to use when constructing the described by .
/// If null, the default constructor is used.
///
public object[]? ConverterParameters { get; }
///
/// Initializes a new instance of the class.
///
/// Type of the .
public JsonConverterAttribute(Type converterType)
{
if (converterType == null)
{
throw new ArgumentNullException(nameof(converterType));
}
_converterType = converterType;
}
///
/// Initializes a new instance of the class.
///
/// Type of the .
/// Parameter list to use when constructing the . Can be null.
public JsonConverterAttribute(Type converterType, params object[] converterParameters)
: this(converterType)
{
ConverterParameters = converterParameters;
}
}
}
================================================
FILE: Src/Newtonsoft.Json/JsonConverterCollection.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
using System.Collections.Generic;
using System.Text;
using System.Collections.ObjectModel;
namespace Newtonsoft.Json
{
///
/// Represents a collection of .
///
public class JsonConverterCollection : Collection
{
}
}
================================================
FILE: Src/Newtonsoft.Json/JsonDictionaryAttribute.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
namespace Newtonsoft.Json
{
///
/// Instructs the how to serialize the collection.
///
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = false)]
public sealed class JsonDictionaryAttribute : JsonContainerAttribute
{
///
/// Initializes a new instance of the class.
///
public JsonDictionaryAttribute()
{
}
///
/// Initializes a new instance of the class with the specified container Id.
///
/// The container Id.
public JsonDictionaryAttribute(string id)
: base(id)
{
}
}
}
================================================
FILE: Src/Newtonsoft.Json/JsonException.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Runtime.Serialization;
using System.Text;
using Newtonsoft.Json.Utilities;
namespace Newtonsoft.Json
{
///
/// The exception thrown when an error occurs during JSON serialization or deserialization.
///
#if HAVE_BINARY_EXCEPTION_SERIALIZATION
[Serializable]
#endif
public class JsonException : Exception
{
///
/// Initializes a new instance of the class.
///
public JsonException()
{
}
///
/// Initializes a new instance of the class
/// with a specified error message.
///
/// The error message that explains the reason for the exception.
public JsonException(string message)
: base(message)
{
}
///
/// Initializes a new instance of the class
/// with a specified error message and a reference to the inner exception that is the cause of this exception.
///
/// The error message that explains the reason for the exception.
/// The exception that is the cause of the current exception, or null if no inner exception is specified.
public JsonException(string message, Exception? innerException)
: base(message, innerException)
{
}
#if HAVE_BINARY_EXCEPTION_SERIALIZATION
///
/// Initializes a new instance of the class.
///
/// The that holds the serialized object data about the exception being thrown.
/// The that contains contextual information about the source or destination.
/// The parameter is null.
/// The class name is null or is zero (0).
#pragma warning disable SYSLIB0051
public JsonException(SerializationInfo info, StreamingContext context)
: base(info, context)
{
}
#pragma warning restore SYSLIB0051
#endif
internal static JsonException Create(IJsonLineInfo lineInfo, string path, string message)
{
message = JsonPosition.FormatMessage(lineInfo, path, message);
return new JsonException(message);
}
}
}
================================================
FILE: Src/Newtonsoft.Json/JsonExtensionDataAttribute.cs
================================================
using System;
namespace Newtonsoft.Json
{
///
/// Instructs the to deserialize properties with no matching class member into the specified collection
/// and write values during serialization.
///
[AttributeUsage(AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = false)]
public class JsonExtensionDataAttribute : Attribute
{
///
/// Gets or sets a value that indicates whether to write extension data when serializing the object.
///
///
/// true to write extension data when serializing the object; otherwise, false. The default is true.
///
public bool WriteData { get; set; }
///
/// Gets or sets a value that indicates whether to read extension data when deserializing the object.
///
///
/// true to read extension data when deserializing the object; otherwise, false. The default is true.
///
public bool ReadData { get; set; }
///
/// Initializes a new instance of the class.
///
public JsonExtensionDataAttribute()
{
WriteData = true;
ReadData = true;
}
}
}
================================================
FILE: Src/Newtonsoft.Json/JsonIgnoreAttribute.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
using System.Collections.Generic;
using System.Text;
namespace Newtonsoft.Json
{
///
/// Instructs the not to serialize the public field or public read/write property value.
///
[AttributeUsage(AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = false)]
public sealed class JsonIgnoreAttribute : Attribute
{
}
}
================================================
FILE: Src/Newtonsoft.Json/JsonNameTable.cs
================================================
namespace Newtonsoft.Json
{
///
/// Base class for a table of atomized string objects.
///
public abstract class JsonNameTable
{
///
/// Gets a string containing the same characters as the specified range of characters in the given array.
///
/// The character array containing the name to find.
/// The zero-based index into the array specifying the first character of the name.
/// The number of characters in the name.
/// A string containing the same characters as the specified range of characters in the given array.
public abstract string? Get(char[] key, int start, int length);
}
}
================================================
FILE: Src/Newtonsoft.Json/JsonObjectAttribute.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
namespace Newtonsoft.Json
{
///
/// Instructs the how to serialize the object.
///
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface, AllowMultiple = false)]
public sealed class JsonObjectAttribute : JsonContainerAttribute
{
private MemberSerialization _memberSerialization = MemberSerialization.OptOut;
internal MissingMemberHandling? _missingMemberHandling;
// yuck. can't set nullable properties on an attribute in C#
// have to use this approach to get an unset default state
internal Required? _itemRequired;
internal NullValueHandling? _itemNullValueHandling;
///
/// Gets or sets the member serialization.
///
/// The member serialization.
public MemberSerialization MemberSerialization
{
get => _memberSerialization;
set => _memberSerialization = value;
}
///
/// Gets or sets the missing member handling used when deserializing this object.
///
/// The missing member handling.
public MissingMemberHandling MissingMemberHandling
{
get => _missingMemberHandling ?? default;
set => _missingMemberHandling = value;
}
///
/// Gets or sets how the object's properties with null values are handled during serialization and deserialization.
///
/// How the object's properties with null values are handled during serialization and deserialization.
public NullValueHandling ItemNullValueHandling
{
get => _itemNullValueHandling ?? default;
set => _itemNullValueHandling = value;
}
///
/// Gets or sets a value that indicates whether the object's properties are required.
///
///
/// A value indicating whether the object's properties are required.
///
public Required ItemRequired
{
get => _itemRequired ?? default;
set => _itemRequired = value;
}
///
/// Initializes a new instance of the class.
///
public JsonObjectAttribute()
{
}
///
/// Initializes a new instance of the class with the specified member serialization.
///
/// The member serialization.
public JsonObjectAttribute(MemberSerialization memberSerialization)
{
MemberSerialization = memberSerialization;
}
///
/// Initializes a new instance of the class with the specified container Id.
///
/// The container Id.
public JsonObjectAttribute(string id)
: base(id)
{
}
}
}
================================================
FILE: Src/Newtonsoft.Json/JsonPosition.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Text;
using Newtonsoft.Json.Utilities;
namespace Newtonsoft.Json
{
internal enum JsonContainerType
{
None = 0,
Object = 1,
Array = 2,
Constructor = 3
}
internal struct JsonPosition
{
private static readonly char[] SpecialCharacters = { '.', ' ', '\'', '/', '"', '[', ']', '(', ')', '\t', '\n', '\r', '\f', '\b', '\\', '\u0085', '\u2028', '\u2029' };
internal JsonContainerType Type;
internal int Position;
internal string? PropertyName;
internal bool HasIndex;
public JsonPosition(JsonContainerType type)
{
Type = type;
HasIndex = TypeHasIndex(type);
Position = -1;
PropertyName = null;
}
internal int CalculateLength()
{
switch (Type)
{
case JsonContainerType.Object:
return PropertyName!.Length + 5;
case JsonContainerType.Array:
case JsonContainerType.Constructor:
return MathUtils.IntLength((ulong)Position) + 2;
default:
throw new ArgumentOutOfRangeException(nameof(Type));
}
}
internal void WriteTo(StringBuilder sb, ref StringWriter? writer, ref char[]? buffer)
{
switch (Type)
{
case JsonContainerType.Object:
string propertyName = PropertyName!;
if (propertyName.IndexOfAny(SpecialCharacters) != -1)
{
sb.Append(@"['");
if (writer == null)
{
writer = new StringWriter(sb);
}
JavaScriptUtils.WriteEscapedJavaScriptString(writer, propertyName, '\'', false, JavaScriptUtils.SingleQuoteCharEscapeFlags, StringEscapeHandling.Default, null, ref buffer);
sb.Append(@"']");
}
else
{
if (sb.Length > 0)
{
sb.Append('.');
}
sb.Append(propertyName);
}
break;
case JsonContainerType.Array:
case JsonContainerType.Constructor:
sb.Append('[');
sb.Append(Position);
sb.Append(']');
break;
}
}
internal static bool TypeHasIndex(JsonContainerType type)
{
return (type == JsonContainerType.Array || type == JsonContainerType.Constructor);
}
internal static string BuildPath(List positions, JsonPosition? currentPosition)
{
int capacity = 0;
if (positions != null)
{
for (int i = 0; i < positions.Count; i++)
{
capacity += positions[i].CalculateLength();
}
}
if (currentPosition != null)
{
capacity += currentPosition.GetValueOrDefault().CalculateLength();
}
StringBuilder sb = new StringBuilder(capacity);
StringWriter? writer = null;
char[]? buffer = null;
if (positions != null)
{
foreach (JsonPosition state in positions)
{
state.WriteTo(sb, ref writer, ref buffer);
}
}
if (currentPosition != null)
{
currentPosition.GetValueOrDefault().WriteTo(sb, ref writer, ref buffer);
}
return sb.ToString();
}
internal static string FormatMessage(IJsonLineInfo? lineInfo, string path, string message)
{
// don't add a fullstop and space when message ends with a new line
if (!message.EndsWith(Environment.NewLine, StringComparison.Ordinal))
{
message = message.Trim();
if (!message.EndsWith('.'))
{
message += ".";
}
message += " ";
}
message += "Path '{0}'".FormatWith(CultureInfo.InvariantCulture, path);
if (lineInfo != null && lineInfo.HasLineInfo())
{
message += ", line {0}, position {1}".FormatWith(CultureInfo.InvariantCulture, lineInfo.LineNumber, lineInfo.LinePosition);
}
message += ".";
return message;
}
}
}
================================================
FILE: Src/Newtonsoft.Json/JsonPropertyAttribute.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
using Newtonsoft.Json.Serialization;
namespace Newtonsoft.Json
{
///
/// Instructs the to always serialize the member with the specified name.
///
[AttributeUsage(AttributeTargets.Field | AttributeTargets.Property | AttributeTargets.Parameter, AllowMultiple = false)]
public sealed class JsonPropertyAttribute : Attribute
{
// yuck. can't set nullable properties on an attribute in C#
// have to use this approach to get an unset default state
internal NullValueHandling? _nullValueHandling;
internal DefaultValueHandling? _defaultValueHandling;
internal ReferenceLoopHandling? _referenceLoopHandling;
internal ObjectCreationHandling? _objectCreationHandling;
internal TypeNameHandling? _typeNameHandling;
internal bool? _isReference;
internal int? _order;
internal Required? _required;
internal bool? _itemIsReference;
internal ReferenceLoopHandling? _itemReferenceLoopHandling;
internal TypeNameHandling? _itemTypeNameHandling;
///
/// Gets or sets the type used when serializing the property's collection items.
///
/// The collection's items type.
public Type? ItemConverterType { get; set; }
///
/// The parameter list to use when constructing the described by .
/// If null, the default constructor is used.
/// When non-null, there must be a constructor defined in the that exactly matches the number,
/// order, and type of these parameters.
///
///
///
/// [JsonProperty(ItemConverterType = typeof(MyContainerConverter), ItemConverterParameters = new object[] { 123, "Four" })]
///
///
public object[]? ItemConverterParameters { get; set; }
///
/// Gets or sets the of the .
///
/// The of the .
public Type? NamingStrategyType { get; set; }
///
/// The parameter list to use when constructing the described by .
/// If null, the default constructor is used.
/// When non-null, there must be a constructor defined in the that exactly matches the number,
/// order, and type of these parameters.
///
///
///
/// [JsonProperty(NamingStrategyType = typeof(MyNamingStrategy), NamingStrategyParameters = new object[] { 123, "Four" })]
///
///
public object[]? NamingStrategyParameters { get; set; }
///
/// Gets or sets the null value handling used when serializing this property.
///
/// The null value handling.
public NullValueHandling NullValueHandling
{
get => _nullValueHandling ?? default;
set => _nullValueHandling = value;
}
///
/// Gets or sets the default value handling used when serializing this property.
///
/// The default value handling.
public DefaultValueHandling DefaultValueHandling
{
get => _defaultValueHandling ?? default;
set => _defaultValueHandling = value;
}
///
/// Gets or sets the reference loop handling used when serializing this property.
///
/// The reference loop handling.
public ReferenceLoopHandling ReferenceLoopHandling
{
get => _referenceLoopHandling ?? default;
set => _referenceLoopHandling = value;
}
///
/// Gets or sets the object creation handling used when deserializing this property.
///
/// The object creation handling.
public ObjectCreationHandling ObjectCreationHandling
{
get => _objectCreationHandling ?? default;
set => _objectCreationHandling = value;
}
///
/// Gets or sets the type name handling used when serializing this property.
///
/// The type name handling.
public TypeNameHandling TypeNameHandling
{
get => _typeNameHandling ?? default;
set => _typeNameHandling = value;
}
///
/// Gets or sets whether this property's value is serialized as a reference.
///
/// Whether this property's value is serialized as a reference.
public bool IsReference
{
get => _isReference ?? default;
set => _isReference = value;
}
///
/// Gets or sets the order of serialization of a member.
///
/// The numeric order of serialization.
public int Order
{
get => _order ?? default;
set => _order = value;
}
///
/// Gets or sets a value indicating whether this property is required.
///
///
/// A value indicating whether this property is required.
///
public Required Required
{
get => _required ?? Required.Default;
set => _required = value;
}
///
/// Gets or sets the name of the property.
///
/// The name of the property.
public string? PropertyName { get; set; }
///
/// Gets or sets the reference loop handling used when serializing the property's collection items.
///
/// The collection's items reference loop handling.
public ReferenceLoopHandling ItemReferenceLoopHandling
{
get => _itemReferenceLoopHandling ?? default;
set => _itemReferenceLoopHandling = value;
}
///
/// Gets or sets the type name handling used when serializing the property's collection items.
///
/// The collection's items type name handling.
public TypeNameHandling ItemTypeNameHandling
{
get => _itemTypeNameHandling ?? default;
set => _itemTypeNameHandling = value;
}
///
/// Gets or sets whether this property's collection items are serialized as a reference.
///
/// Whether this property's collection items are serialized as a reference.
public bool ItemIsReference
{
get => _itemIsReference ?? default;
set => _itemIsReference = value;
}
///
/// Initializes a new instance of the class.
///
public JsonPropertyAttribute()
{
}
///
/// Initializes a new instance of the class with the specified name.
///
/// Name of the property.
public JsonPropertyAttribute(string propertyName)
{
PropertyName = propertyName;
}
}
}
================================================
FILE: Src/Newtonsoft.Json/JsonReader.Async.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
#if HAVE_ASYNC
using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using Newtonsoft.Json.Utilities;
namespace Newtonsoft.Json
{
public abstract partial class JsonReader
#if HAVE_ASYNC_DISPOSABLE
: IAsyncDisposable
#endif
{
#if HAVE_ASYNC_DISPOSABLE
ValueTask IAsyncDisposable.DisposeAsync()
{
try
{
Dispose(true);
return default;
}
catch (Exception exc)
{
return ValueTask.FromException(exc);
}
}
#endif
///
/// Asynchronously reads the next JSON token from the source.
///
/// The token to monitor for cancellation requests. The default value is .
/// A that represents the asynchronous read. The
/// property returns true if the next token was read successfully; false if there are no more tokens to read.
/// The default behaviour is to execute synchronously, returning an already-completed task. Derived
/// classes can override this behaviour for true asynchronicity.
public virtual Task ReadAsync(CancellationToken cancellationToken = default)
{
return cancellationToken.CancelIfRequestedAsync() ?? Read().ToAsync();
}
///
/// Asynchronously skips the children of the current token.
///
/// The token to monitor for cancellation requests. The default value is .
/// A that represents the asynchronous operation.
/// The default behaviour is to execute synchronously, returning an already-completed task. Derived
/// classes can override this behaviour for true asynchronicity.
public async Task SkipAsync(CancellationToken cancellationToken = default)
{
if (TokenType == JsonToken.PropertyName)
{
await ReadAsync(cancellationToken).ConfigureAwait(false);
}
if (JsonTokenUtils.IsStartToken(TokenType))
{
int depth = Depth;
while (await ReadAsync(cancellationToken).ConfigureAwait(false) && depth < Depth)
{
}
}
}
internal async Task ReaderReadAndAssertAsync(CancellationToken cancellationToken)
{
if (!await ReadAsync(cancellationToken).ConfigureAwait(false))
{
throw CreateUnexpectedEndException();
}
}
///
/// Asynchronously reads the next JSON token from the source as a of .
///
/// The token to monitor for cancellation requests. The default value is .
/// A that represents the asynchronous read. The
/// property returns the of . This result will be null at the end of an array.
/// The default behaviour is to execute synchronously, returning an already-completed task. Derived
/// classes can override this behaviour for true asynchronicity.
public virtual Task ReadAsBooleanAsync(CancellationToken cancellationToken = default)
{
return cancellationToken.CancelIfRequestedAsync() ?? Task.FromResult(ReadAsBoolean());
}
///
/// Asynchronously reads the next JSON token from the source as a [].
///
/// The token to monitor for cancellation requests. The default value is .
/// A that represents the asynchronous read. The
/// property returns the []. This result will be null at the end of an array.
/// The default behaviour is to execute synchronously, returning an already-completed task. Derived
/// classes can override this behaviour for true asynchronicity.
public virtual Task ReadAsBytesAsync(CancellationToken cancellationToken = default)
{
return cancellationToken.CancelIfRequestedAsync() ?? Task.FromResult(ReadAsBytes());
}
internal async Task ReadArrayIntoByteArrayAsync(CancellationToken cancellationToken)
{
List buffer = new List();
while (true)
{
if (!await ReadAsync(cancellationToken).ConfigureAwait(false))
{
SetToken(JsonToken.None);
}
if (ReadArrayElementIntoByteArrayReportDone(buffer))
{
byte[] d = buffer.ToArray();
SetToken(JsonToken.Bytes, d, false);
return d;
}
}
}
///
/// Asynchronously reads the next JSON token from the source as a of .
///
/// The token to monitor for cancellation requests. The default value is .
/// A that represents the asynchronous read. The
/// property returns the of . This result will be null at the end of an array.
/// The default behaviour is to execute synchronously, returning an already-completed task. Derived
/// classes can override this behaviour for true asynchronicity.
public virtual Task ReadAsDateTimeAsync(CancellationToken cancellationToken = default)
{
return cancellationToken.CancelIfRequestedAsync() ?? Task.FromResult(ReadAsDateTime());
}
///
/// Asynchronously reads the next JSON token from the source as a of .
///
/// The token to monitor for cancellation requests. The default value is .
/// A that represents the asynchronous read. The
/// property returns the of . This result will be null at the end of an array.
/// The default behaviour is to execute synchronously, returning an already-completed task. Derived
/// classes can override this behaviour for true asynchronicity.
public virtual Task ReadAsDateTimeOffsetAsync(CancellationToken cancellationToken = default)
{
return cancellationToken.CancelIfRequestedAsync() ?? Task.FromResult(ReadAsDateTimeOffset());
}
///
/// Asynchronously reads the next JSON token from the source as a of .
///
/// The token to monitor for cancellation requests. The default value is .
/// A that represents the asynchronous read. The
/// property returns the of . This result will be null at the end of an array.
/// The default behaviour is to execute synchronously, returning an already-completed task. Derived
/// classes can override this behaviour for true asynchronicity.
public virtual Task ReadAsDecimalAsync(CancellationToken cancellationToken = default)
{
return cancellationToken.CancelIfRequestedAsync() ?? Task.FromResult(ReadAsDecimal());
}
///
/// Asynchronously reads the next JSON token from the source as a of .
///
/// The token to monitor for cancellation requests. The default value is .
/// A that represents the asynchronous read. The
/// property returns the of . This result will be null at the end of an array.
/// The default behaviour is to execute synchronously, returning an already-completed task. Derived
/// classes can override this behaviour for true asynchronicity.
public virtual Task ReadAsDoubleAsync(CancellationToken cancellationToken = default)
{
return Task.FromResult(ReadAsDouble());
}
///
/// Asynchronously reads the next JSON token from the source as a of .
///
/// The token to monitor for cancellation requests. The default value is .
/// A that represents the asynchronous read. The
/// property returns the of . This result will be null at the end of an array.
/// The default behaviour is to execute synchronously, returning an already-completed task. Derived
/// classes can override this behaviour for true asynchronicity.
public virtual Task ReadAsInt32Async(CancellationToken cancellationToken = default)
{
return cancellationToken.CancelIfRequestedAsync() ?? Task.FromResult(ReadAsInt32());
}
///
/// Asynchronously reads the next JSON token from the source as a .
///
/// The token to monitor for cancellation requests. The default value is .
/// A that represents the asynchronous read. The
/// property returns the . This result will be null at the end of an array.
/// The default behaviour is to execute synchronously, returning an already-completed task. Derived
/// classes can override this behaviour for true asynchronicity.
public virtual Task ReadAsStringAsync(CancellationToken cancellationToken = default)
{
return cancellationToken.CancelIfRequestedAsync() ?? Task.FromResult(ReadAsString());
}
internal async Task ReadAndMoveToContentAsync(CancellationToken cancellationToken)
{
return await ReadAsync(cancellationToken).ConfigureAwait(false) && await MoveToContentAsync(cancellationToken).ConfigureAwait(false);
}
internal Task MoveToContentAsync(CancellationToken cancellationToken)
{
switch (TokenType)
{
case JsonToken.None:
case JsonToken.Comment:
return MoveToContentFromNonContentAsync(cancellationToken);
default:
return AsyncUtils.True;
}
}
private async Task MoveToContentFromNonContentAsync(CancellationToken cancellationToken)
{
while (true)
{
if (!await ReadAsync(cancellationToken).ConfigureAwait(false))
{
return false;
}
switch (TokenType)
{
case JsonToken.None:
case JsonToken.Comment:
break;
default:
return true;
}
}
}
}
}
#endif
================================================
FILE: Src/Newtonsoft.Json/JsonReader.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
using System.Collections.Generic;
using System.IO;
using System.Globalization;
#if HAVE_BIG_INTEGER
using System.Numerics;
#endif
using Newtonsoft.Json.Serialization;
using Newtonsoft.Json.Utilities;
namespace Newtonsoft.Json
{
///
/// Represents a reader that provides fast, non-cached, forward-only access to serialized JSON data.
///
public abstract partial class JsonReader : IDisposable
{
///
/// Specifies the state of the reader.
///
protected internal enum State
{
///
/// A read method has not been called.
///
Start,
///
/// The end of the file has been reached successfully.
///
Complete,
///
/// Reader is at a property.
///
Property,
///
/// Reader is at the start of an object.
///
ObjectStart,
///
/// Reader is in an object.
///
Object,
///
/// Reader is at the start of an array.
///
ArrayStart,
///
/// Reader is in an array.
///
Array,
///
/// The method has been called.
///
Closed,
///
/// Reader has just read a value.
///
PostValue,
///
/// Reader is at the start of a constructor.
///
ConstructorStart,
///
/// Reader is in a constructor.
///
Constructor,
///
/// An error occurred that prevents the read operation from continuing.
///
Error,
///
/// The end of the file has been reached successfully.
///
Finished
}
// current Token data
private JsonToken _tokenType;
private object? _value;
internal char _quoteChar;
internal State _currentState;
private JsonPosition _currentPosition;
private CultureInfo? _culture;
private DateTimeZoneHandling _dateTimeZoneHandling;
private int? _maxDepth;
private bool _hasExceededMaxDepth;
internal DateParseHandling _dateParseHandling;
internal FloatParseHandling _floatParseHandling;
private string? _dateFormatString;
private List? _stack;
///
/// Gets the current reader state.
///
/// The current reader state.
protected State CurrentState => _currentState;
///
/// Gets or sets a value indicating whether the source should be closed when this reader is closed.
///
///
/// true to close the source when this reader is closed; otherwise false. The default is true.
///
public bool CloseInput { get; set; }
///
/// Gets or sets a value indicating whether multiple pieces of JSON content can
/// be read from a continuous stream without erroring.
///
///
/// true to support reading multiple pieces of JSON content; otherwise false.
/// The default is false.
///
public bool SupportMultipleContent { get; set; }
///
/// Gets the quotation mark character used to enclose the value of a string.
///
public virtual char QuoteChar
{
get => _quoteChar;
protected internal set => _quoteChar = value;
}
///
/// Gets or sets how time zones are handled when reading JSON.
///
public DateTimeZoneHandling DateTimeZoneHandling
{
get => _dateTimeZoneHandling;
set
{
if (value < DateTimeZoneHandling.Local || value > DateTimeZoneHandling.RoundtripKind)
{
throw new ArgumentOutOfRangeException(nameof(value));
}
_dateTimeZoneHandling = value;
}
}
///
/// Gets or sets how date formatted strings, e.g. "\/Date(1198908717056)\/" and "2012-03-21T05:40Z", are parsed when reading JSON.
///
public DateParseHandling DateParseHandling
{
get => _dateParseHandling;
set
{
if (value < DateParseHandling.None ||
#if HAVE_DATE_TIME_OFFSET
value > DateParseHandling.DateTimeOffset
#else
value > DateParseHandling.DateTime
#endif
)
{
throw new ArgumentOutOfRangeException(nameof(value));
}
_dateParseHandling = value;
}
}
///
/// Gets or sets how floating point numbers, e.g. 1.0 and 9.9, are parsed when reading JSON text.
///
public FloatParseHandling FloatParseHandling
{
get => _floatParseHandling;
set
{
if (value < FloatParseHandling.Double || value > FloatParseHandling.Decimal)
{
throw new ArgumentOutOfRangeException(nameof(value));
}
_floatParseHandling = value;
}
}
///
/// Gets or sets how custom date formatted strings are parsed when reading JSON.
///
public string? DateFormatString
{
get => _dateFormatString;
set => _dateFormatString = value;
}
///
/// Gets or sets the maximum depth allowed when reading JSON. Reading past this depth will throw a .
/// A null value means there is no maximum.
/// The default value is 64.
///
public int? MaxDepth
{
get => _maxDepth;
set
{
if (value <= 0)
{
throw new ArgumentException("Value must be positive.", nameof(value));
}
_maxDepth = value;
}
}
///
/// Gets the type of the current JSON token.
///
public virtual JsonToken TokenType => _tokenType;
///
/// Gets the text value of the current JSON token.
///
public virtual object? Value => _value;
///
/// Gets the .NET type for the current JSON token.
///
public virtual Type? ValueType => _value?.GetType();
///
/// Gets the depth of the current token in the JSON document.
///
/// The depth of the current token in the JSON document.
public virtual int Depth
{
get
{
int depth = _stack?.Count ?? 0;
if (JsonTokenUtils.IsStartToken(TokenType) || _currentPosition.Type == JsonContainerType.None)
{
return depth;
}
else
{
return depth + 1;
}
}
}
///
/// Gets the path of the current JSON token.
///
public virtual string Path
{
get
{
if (_currentPosition.Type == JsonContainerType.None)
{
return string.Empty;
}
bool insideContainer = (_currentState != State.ArrayStart
&& _currentState != State.ConstructorStart
&& _currentState != State.ObjectStart);
JsonPosition? current = insideContainer ? (JsonPosition?)_currentPosition : null;
return JsonPosition.BuildPath(_stack!, current);
}
}
///
/// Gets or sets the culture used when reading JSON. Defaults to .
///
public CultureInfo Culture
{
get => _culture ?? CultureInfo.InvariantCulture;
set => _culture = value;
}
internal JsonPosition GetPosition(int depth)
{
if (_stack != null && depth < _stack.Count)
{
return _stack[depth];
}
return _currentPosition;
}
///
/// Initializes a new instance of the class.
///
protected JsonReader()
{
_currentState = State.Start;
_dateTimeZoneHandling = DateTimeZoneHandling.RoundtripKind;
_dateParseHandling = DateParseHandling.DateTime;
_floatParseHandling = FloatParseHandling.Double;
_maxDepth = 64;
CloseInput = true;
}
private void Push(JsonContainerType value)
{
UpdateScopeWithFinishedValue();
if (_currentPosition.Type == JsonContainerType.None)
{
_currentPosition = new JsonPosition(value);
}
else
{
if (_stack == null)
{
_stack = new List();
}
_stack.Add(_currentPosition);
_currentPosition = new JsonPosition(value);
// this is a little hacky because Depth increases when first property/value is written but only testing here is faster/simpler
if (_maxDepth != null && Depth + 1 > _maxDepth && !_hasExceededMaxDepth)
{
_hasExceededMaxDepth = true;
throw JsonReaderException.Create(this, "The reader's MaxDepth of {0} has been exceeded.".FormatWith(CultureInfo.InvariantCulture, _maxDepth));
}
}
}
private JsonContainerType Pop()
{
JsonPosition oldPosition;
if (_stack != null && _stack.Count > 0)
{
oldPosition = _currentPosition;
_currentPosition = _stack[_stack.Count - 1];
_stack.RemoveAt(_stack.Count - 1);
}
else
{
oldPosition = _currentPosition;
_currentPosition = new JsonPosition();
}
if (_maxDepth != null && Depth <= _maxDepth)
{
_hasExceededMaxDepth = false;
}
return oldPosition.Type;
}
private JsonContainerType Peek()
{
return _currentPosition.Type;
}
///
/// Reads the next JSON token from the source.
///
/// true if the next token was read successfully; false if there are no more tokens to read.
public abstract bool Read();
///
/// Reads the next JSON token from the source as a of .
///
/// A of . This method will return null at the end of an array.
public virtual int? ReadAsInt32()
{
JsonToken t = GetContentToken();
switch (t)
{
case JsonToken.None:
case JsonToken.Null:
case JsonToken.EndArray:
return null;
case JsonToken.Integer:
case JsonToken.Float:
object v = Value!;
if (v is int i)
{
return i;
}
#if HAVE_BIG_INTEGER
if (v is BigInteger value)
{
i = (int)value;
}
else
#endif
{
try
{
i = Convert.ToInt32(v, CultureInfo.InvariantCulture);
}
catch (Exception ex)
{
// handle error for large integer overflow exceptions
throw JsonReaderException.Create(this, "Could not convert to integer: {0}.".FormatWith(CultureInfo.InvariantCulture, v), ex);
}
}
SetToken(JsonToken.Integer, i, false);
return i;
case JsonToken.String:
string? s = (string?)Value;
return ReadInt32String(s);
}
throw JsonReaderException.Create(this, "Error reading integer. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, t));
}
internal int? ReadInt32String(string? s)
{
if (StringUtils.IsNullOrEmpty(s))
{
SetToken(JsonToken.Null, null, false);
return null;
}
if (int.TryParse(s, NumberStyles.Integer, Culture, out int i))
{
SetToken(JsonToken.Integer, i, false);
return i;
}
else
{
SetToken(JsonToken.String, s, false);
throw JsonReaderException.Create(this, "Could not convert string to integer: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
}
}
///
/// Reads the next JSON token from the source as a .
///
/// A . This method will return null at the end of an array.
public virtual string? ReadAsString()
{
JsonToken t = GetContentToken();
switch (t)
{
case JsonToken.None:
case JsonToken.Null:
case JsonToken.EndArray:
return null;
case JsonToken.String:
return (string?)Value;
}
if (JsonTokenUtils.IsPrimitiveToken(t))
{
object? v = Value;
if (v != null)
{
string s;
if (v is IFormattable formattable)
{
s = formattable.ToString(null, Culture);
}
else
{
s = v is Uri uri ? uri.OriginalString : v.ToString()!;
}
SetToken(JsonToken.String, s, false);
return s;
}
}
throw JsonReaderException.Create(this, "Error reading string. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, t));
}
///
/// Reads the next JSON token from the source as a [].
///
/// A [] or null if the next JSON token is null. This method will return null at the end of an array.
public virtual byte[]? ReadAsBytes()
{
JsonToken t = GetContentToken();
switch (t)
{
case JsonToken.StartObject:
{
ReadIntoWrappedTypeObject();
byte[]? data = ReadAsBytes();
ReaderReadAndAssert();
if (TokenType != JsonToken.EndObject)
{
throw JsonReaderException.Create(this, "Error reading bytes. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, TokenType));
}
SetToken(JsonToken.Bytes, data, false);
return data;
}
case JsonToken.String:
{
// attempt to convert possible base 64 or GUID string to bytes
// GUID has to have format 00000000-0000-0000-0000-000000000000
string s = (string)Value!;
byte[] data;
if (s.Length == 0)
{
data = CollectionUtils.ArrayEmpty();
}
else if (ConvertUtils.TryConvertGuid(s, out Guid g1))
{
data = g1.ToByteArray();
}
else
{
data = Convert.FromBase64String(s);
}
SetToken(JsonToken.Bytes, data, false);
return data;
}
case JsonToken.None:
case JsonToken.Null:
case JsonToken.EndArray:
return null;
case JsonToken.Bytes:
if (Value is Guid g2)
{
byte[] data = g2.ToByteArray();
SetToken(JsonToken.Bytes, data, false);
return data;
}
return (byte[]?)Value;
case JsonToken.StartArray:
return ReadArrayIntoByteArray();
}
throw JsonReaderException.Create(this, "Error reading bytes. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, t));
}
internal byte[] ReadArrayIntoByteArray()
{
List buffer = new List();
while (true)
{
if (!Read())
{
SetToken(JsonToken.None);
}
if (ReadArrayElementIntoByteArrayReportDone(buffer))
{
byte[] d = buffer.ToArray();
SetToken(JsonToken.Bytes, d, false);
return d;
}
}
}
private bool ReadArrayElementIntoByteArrayReportDone(List buffer)
{
switch (TokenType)
{
case JsonToken.None:
throw JsonReaderException.Create(this, "Unexpected end when reading bytes.");
case JsonToken.Integer:
buffer.Add(Convert.ToByte(Value, CultureInfo.InvariantCulture));
return false;
case JsonToken.EndArray:
return true;
case JsonToken.Comment:
return false;
default:
throw JsonReaderException.Create(this, "Unexpected token when reading bytes: {0}.".FormatWith(CultureInfo.InvariantCulture, TokenType));
}
}
///
/// Reads the next JSON token from the source as a of .
///
/// A of . This method will return null at the end of an array.
public virtual double? ReadAsDouble()
{
JsonToken t = GetContentToken();
switch (t)
{
case JsonToken.None:
case JsonToken.Null:
case JsonToken.EndArray:
return null;
case JsonToken.Integer:
case JsonToken.Float:
object v = Value!;
if (v is double d)
{
return d;
}
#if HAVE_BIG_INTEGER
if (v is BigInteger value)
{
d = (double)value;
}
else
#endif
{
d = Convert.ToDouble(v, CultureInfo.InvariantCulture);
}
SetToken(JsonToken.Float, d, false);
return (double)d;
case JsonToken.String:
return ReadDoubleString((string?)Value);
}
throw JsonReaderException.Create(this, "Error reading double. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, t));
}
internal double? ReadDoubleString(string? s)
{
if (StringUtils.IsNullOrEmpty(s))
{
SetToken(JsonToken.Null, null, false);
return null;
}
if (double.TryParse(s, NumberStyles.Float | NumberStyles.AllowThousands, Culture, out double d))
{
SetToken(JsonToken.Float, d, false);
return d;
}
else
{
SetToken(JsonToken.String, s, false);
throw JsonReaderException.Create(this, "Could not convert string to double: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
}
}
///
/// Reads the next JSON token from the source as a of .
///
/// A of . This method will return null at the end of an array.
public virtual bool? ReadAsBoolean()
{
JsonToken t = GetContentToken();
switch (t)
{
case JsonToken.None:
case JsonToken.Null:
case JsonToken.EndArray:
return null;
case JsonToken.Integer:
case JsonToken.Float:
bool b;
#if HAVE_BIG_INTEGER
if (Value is BigInteger integer)
{
b = integer != 0;
}
else
#endif
{
b = Convert.ToBoolean(Value, CultureInfo.InvariantCulture);
}
SetToken(JsonToken.Boolean, b, false);
return b;
case JsonToken.String:
return ReadBooleanString((string?)Value);
case JsonToken.Boolean:
return (bool)Value!;
}
throw JsonReaderException.Create(this, "Error reading boolean. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, t));
}
internal bool? ReadBooleanString(string? s)
{
if (StringUtils.IsNullOrEmpty(s))
{
SetToken(JsonToken.Null, null, false);
return null;
}
if (bool.TryParse(s, out bool b))
{
SetToken(JsonToken.Boolean, b, false);
return b;
}
else
{
SetToken(JsonToken.String, s, false);
throw JsonReaderException.Create(this, "Could not convert string to boolean: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
}
}
///
/// Reads the next JSON token from the source as a of .
///
/// A of . This method will return null at the end of an array.
public virtual decimal? ReadAsDecimal()
{
JsonToken t = GetContentToken();
switch (t)
{
case JsonToken.None:
case JsonToken.Null:
case JsonToken.EndArray:
return null;
case JsonToken.Integer:
case JsonToken.Float:
object v = Value!;
if (v is decimal d)
{
return d;
}
#if HAVE_BIG_INTEGER
if (v is BigInteger value)
{
d = (decimal)value;
}
else
#endif
{
try
{
d = Convert.ToDecimal(v, CultureInfo.InvariantCulture);
}
catch (Exception ex)
{
// handle error for large integer overflow exceptions
throw JsonReaderException.Create(this, "Could not convert to decimal: {0}.".FormatWith(CultureInfo.InvariantCulture, v), ex);
}
}
SetToken(JsonToken.Float, d, false);
return d;
case JsonToken.String:
return ReadDecimalString((string?)Value);
}
throw JsonReaderException.Create(this, "Error reading decimal. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, t));
}
internal decimal? ReadDecimalString(string? s)
{
if (StringUtils.IsNullOrEmpty(s))
{
SetToken(JsonToken.Null, null, false);
return null;
}
if (decimal.TryParse(s, NumberStyles.Number, Culture, out decimal d))
{
SetToken(JsonToken.Float, d, false);
return d;
}
else if (ConvertUtils.DecimalTryParse(s.ToCharArray(), 0, s.Length, out d) == ParseResult.Success)
{
// This is to handle strings like "96.014e-05" that are not supported by traditional decimal.TryParse
SetToken(JsonToken.Float, d, false);
return d;
}
else
{
SetToken(JsonToken.String, s, false);
throw JsonReaderException.Create(this, "Could not convert string to decimal: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
}
}
///
/// Reads the next JSON token from the source as a of .
///
/// A of . This method will return null at the end of an array.
public virtual DateTime? ReadAsDateTime()
{
switch (GetContentToken())
{
case JsonToken.None:
case JsonToken.Null:
case JsonToken.EndArray:
return null;
case JsonToken.Date:
#if HAVE_DATE_TIME_OFFSET
if (Value is DateTimeOffset offset)
{
SetToken(JsonToken.Date, offset.DateTime, false);
}
#endif
return (DateTime)Value!;
case JsonToken.String:
return ReadDateTimeString((string?)Value);
}
throw JsonReaderException.Create(this, "Error reading date. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, TokenType));
}
internal DateTime? ReadDateTimeString(string? s)
{
if (StringUtils.IsNullOrEmpty(s))
{
SetToken(JsonToken.Null, null, false);
return null;
}
if (DateTimeUtils.TryParseDateTime(s, DateTimeZoneHandling, _dateFormatString, Culture, out DateTime dt))
{
dt = DateTimeUtils.EnsureDateTime(dt, DateTimeZoneHandling);
SetToken(JsonToken.Date, dt, false);
return dt;
}
if (DateTime.TryParse(s, Culture, DateTimeStyles.RoundtripKind, out dt))
{
dt = DateTimeUtils.EnsureDateTime(dt, DateTimeZoneHandling);
SetToken(JsonToken.Date, dt, false);
return dt;
}
throw JsonReaderException.Create(this, "Could not convert string to DateTime: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
}
#if HAVE_DATE_TIME_OFFSET
///
/// Reads the next JSON token from the source as a of .
///
/// A of . This method will return null at the end of an array.
public virtual DateTimeOffset? ReadAsDateTimeOffset()
{
JsonToken t = GetContentToken();
switch (t)
{
case JsonToken.None:
case JsonToken.Null:
case JsonToken.EndArray:
return null;
case JsonToken.Date:
if (Value is DateTime time)
{
SetToken(JsonToken.Date, new DateTimeOffset(time), false);
}
return (DateTimeOffset)Value!;
case JsonToken.String:
string? s = (string?)Value;
return ReadDateTimeOffsetString(s);
default:
throw JsonReaderException.Create(this, "Error reading date. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, t));
}
}
internal DateTimeOffset? ReadDateTimeOffsetString(string? s)
{
if (StringUtils.IsNullOrEmpty(s))
{
SetToken(JsonToken.Null, null, false);
return null;
}
if (DateTimeUtils.TryParseDateTimeOffset(s, _dateFormatString, Culture, out DateTimeOffset dt))
{
SetToken(JsonToken.Date, dt, false);
return dt;
}
if (DateTimeOffset.TryParse(s, Culture, DateTimeStyles.RoundtripKind, out dt))
{
SetToken(JsonToken.Date, dt, false);
return dt;
}
SetToken(JsonToken.String, s, false);
throw JsonReaderException.Create(this, "Could not convert string to DateTimeOffset: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
}
#endif
internal void ReaderReadAndAssert()
{
if (!Read())
{
throw CreateUnexpectedEndException();
}
}
internal JsonReaderException CreateUnexpectedEndException()
{
return JsonReaderException.Create(this, "Unexpected end when reading JSON.");
}
internal void ReadIntoWrappedTypeObject()
{
ReaderReadAndAssert();
if (Value != null && Value.ToString() == JsonTypeReflector.TypePropertyName)
{
ReaderReadAndAssert();
if (Value != null && Value.ToString()!.StartsWith("System.Byte[]", StringComparison.Ordinal))
{
ReaderReadAndAssert();
if (Value.ToString() == JsonTypeReflector.ValuePropertyName)
{
return;
}
}
}
throw JsonReaderException.Create(this, "Error reading bytes. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, JsonToken.StartObject));
}
///
/// Skips the children of the current token.
///
public void Skip()
{
if (TokenType == JsonToken.PropertyName)
{
Read();
}
if (JsonTokenUtils.IsStartToken(TokenType))
{
int depth = Depth;
while (Read() && (depth < Depth))
{
}
}
}
///
/// Sets the current token.
///
/// The new token.
protected void SetToken(JsonToken newToken)
{
SetToken(newToken, null, true);
}
///
/// Sets the current token and value.
///
/// The new token.
/// The value.
protected void SetToken(JsonToken newToken, object? value)
{
SetToken(newToken, value, true);
}
///
/// Sets the current token and value.
///
/// The new token.
/// The value.
/// A flag indicating whether the position index inside an array should be updated.
protected void SetToken(JsonToken newToken, object? value, bool updateIndex)
{
_tokenType = newToken;
_value = value;
switch (newToken)
{
case JsonToken.StartObject:
_currentState = State.ObjectStart;
Push(JsonContainerType.Object);
break;
case JsonToken.StartArray:
_currentState = State.ArrayStart;
Push(JsonContainerType.Array);
break;
case JsonToken.StartConstructor:
_currentState = State.ConstructorStart;
Push(JsonContainerType.Constructor);
break;
case JsonToken.EndObject:
ValidateEnd(JsonToken.EndObject);
break;
case JsonToken.EndArray:
ValidateEnd(JsonToken.EndArray);
break;
case JsonToken.EndConstructor:
ValidateEnd(JsonToken.EndConstructor);
break;
case JsonToken.PropertyName:
_currentState = State.Property;
_currentPosition.PropertyName = (string)value!;
break;
case JsonToken.Undefined:
case JsonToken.Integer:
case JsonToken.Float:
case JsonToken.Boolean:
case JsonToken.Null:
case JsonToken.Date:
case JsonToken.String:
case JsonToken.Raw:
case JsonToken.Bytes:
SetPostValueState(updateIndex);
break;
}
}
internal void SetPostValueState(bool updateIndex)
{
if (Peek() != JsonContainerType.None || SupportMultipleContent)
{
_currentState = State.PostValue;
}
else
{
SetFinished();
}
if (updateIndex)
{
UpdateScopeWithFinishedValue();
}
}
private void UpdateScopeWithFinishedValue()
{
if (_currentPosition.HasIndex)
{
_currentPosition.Position++;
}
}
private void ValidateEnd(JsonToken endToken)
{
JsonContainerType currentObject = Pop();
if (GetTypeForCloseToken(endToken) != currentObject)
{
throw JsonReaderException.Create(this, "JsonToken {0} is not valid for closing JsonType {1}.".FormatWith(CultureInfo.InvariantCulture, endToken, currentObject));
}
if (Peek() != JsonContainerType.None || SupportMultipleContent)
{
_currentState = State.PostValue;
}
else
{
SetFinished();
}
}
///
/// Sets the state based on current token type.
///
protected void SetStateBasedOnCurrent()
{
JsonContainerType currentObject = Peek();
switch (currentObject)
{
case JsonContainerType.Object:
_currentState = State.Object;
break;
case JsonContainerType.Array:
_currentState = State.Array;
break;
case JsonContainerType.Constructor:
_currentState = State.Constructor;
break;
case JsonContainerType.None:
SetFinished();
break;
default:
throw JsonReaderException.Create(this, "While setting the reader state back to current object an unexpected JsonType was encountered: {0}".FormatWith(CultureInfo.InvariantCulture, currentObject));
}
}
private void SetFinished()
{
_currentState = SupportMultipleContent ? State.Start : State.Finished;
}
private JsonContainerType GetTypeForCloseToken(JsonToken token)
{
switch (token)
{
case JsonToken.EndObject:
return JsonContainerType.Object;
case JsonToken.EndArray:
return JsonContainerType.Array;
case JsonToken.EndConstructor:
return JsonContainerType.Constructor;
default:
throw JsonReaderException.Create(this, "Not a valid close JsonToken: {0}".FormatWith(CultureInfo.InvariantCulture, token));
}
}
void IDisposable.Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
///
/// Releases unmanaged and - optionally - managed resources.
///
/// true to release both managed and unmanaged resources; false to release only unmanaged resources.
protected virtual void Dispose(bool disposing)
{
if (_currentState != State.Closed && disposing)
{
Close();
}
}
///
/// Changes the reader's state to .
/// If is set to true, the source is also closed.
///
public virtual void Close()
{
_currentState = State.Closed;
_tokenType = JsonToken.None;
_value = null;
}
internal void ReadAndAssert()
{
if (!Read())
{
throw JsonSerializationException.Create(this, "Unexpected end when reading JSON.");
}
}
internal void ReadForTypeAndAssert(JsonContract? contract, bool hasConverter)
{
if (!ReadForType(contract, hasConverter))
{
throw JsonSerializationException.Create(this, "Unexpected end when reading JSON.");
}
}
internal bool ReadForType(JsonContract? contract, bool hasConverter)
{
// don't read properties with converters as a specific value
// the value might be a string which will then get converted which will error if read as date for example
if (hasConverter)
{
return Read();
}
ReadType t = contract?.InternalReadType ?? ReadType.Read;
switch (t)
{
case ReadType.Read:
return ReadAndMoveToContent();
case ReadType.ReadAsInt32:
ReadAsInt32();
break;
case ReadType.ReadAsInt64:
bool result = ReadAndMoveToContent();
if (TokenType == JsonToken.Undefined)
{
throw JsonReaderException.Create(this, "An undefined token is not a valid {0}.".FormatWith(CultureInfo.InvariantCulture, contract?.UnderlyingType ?? typeof(long)));
}
return result;
case ReadType.ReadAsDecimal:
ReadAsDecimal();
break;
case ReadType.ReadAsDouble:
ReadAsDouble();
break;
case ReadType.ReadAsBytes:
ReadAsBytes();
break;
case ReadType.ReadAsBoolean:
ReadAsBoolean();
break;
case ReadType.ReadAsString:
ReadAsString();
break;
case ReadType.ReadAsDateTime:
ReadAsDateTime();
break;
#if HAVE_DATE_TIME_OFFSET
case ReadType.ReadAsDateTimeOffset:
ReadAsDateTimeOffset();
break;
#endif
default:
throw new ArgumentOutOfRangeException();
}
return (TokenType != JsonToken.None);
}
internal bool ReadAndMoveToContent()
{
return Read() && MoveToContent();
}
internal bool MoveToContent()
{
JsonToken t = TokenType;
while (t == JsonToken.None || t == JsonToken.Comment)
{
if (!Read())
{
return false;
}
t = TokenType;
}
return true;
}
private JsonToken GetContentToken()
{
JsonToken t;
do
{
if (!Read())
{
SetToken(JsonToken.None);
return JsonToken.None;
}
else
{
t = TokenType;
}
} while (t == JsonToken.Comment);
return t;
}
}
}
================================================
FILE: Src/Newtonsoft.Json/JsonReaderException.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
using System.Globalization;
using System.Runtime.Serialization;
using Newtonsoft.Json.Utilities;
namespace Newtonsoft.Json
{
///
/// The exception thrown when an error occurs while reading JSON text.
///
#if HAVE_BINARY_EXCEPTION_SERIALIZATION
[Serializable]
#endif
public class JsonReaderException : JsonException
{
///
/// Gets the line number indicating where the error occurred.
///
/// The line number indicating where the error occurred.
public int LineNumber { get; }
///
/// Gets the line position indicating where the error occurred.
///
/// The line position indicating where the error occurred.
public int LinePosition { get; }
///
/// Gets the path to the JSON where the error occurred.
///
/// The path to the JSON where the error occurred.
public string? Path { get; }
///
/// Initializes a new instance of the class.
///
public JsonReaderException()
{
}
///
/// Initializes a new instance of the class
/// with a specified error message.
///
/// The error message that explains the reason for the exception.
public JsonReaderException(string message)
: base(message)
{
}
///
/// Initializes a new instance of the class
/// with a specified error message and a reference to the inner exception that is the cause of this exception.
///
/// The error message that explains the reason for the exception.
/// The exception that is the cause of the current exception, or null if no inner exception is specified.
public JsonReaderException(string message, Exception innerException)
: base(message, innerException)
{
}
#if HAVE_BINARY_EXCEPTION_SERIALIZATION
///
/// Initializes a new instance of the class.
///
/// The that holds the serialized object data about the exception being thrown.
/// The that contains contextual information about the source or destination.
/// The parameter is null.
/// The class name is null or is zero (0).
public JsonReaderException(SerializationInfo info, StreamingContext context)
: base(info, context)
{
}
#endif
///
/// Initializes a new instance of the class
/// with a specified error message, JSON path, line number, line position, and a reference to the inner exception that is the cause of this exception.
///
/// The error message that explains the reason for the exception.
/// The path to the JSON where the error occurred.
/// The line number indicating where the error occurred.
/// The line position indicating where the error occurred.
/// The exception that is the cause of the current exception, or null if no inner exception is specified.
public JsonReaderException(string message, string path, int lineNumber, int linePosition, Exception? innerException)
: base(message, innerException)
{
Path = path;
LineNumber = lineNumber;
LinePosition = linePosition;
}
internal static JsonReaderException Create(JsonReader reader, string message)
{
return Create(reader, message, null);
}
internal static JsonReaderException Create(JsonReader reader, string message, Exception? ex)
{
return Create(reader as IJsonLineInfo, reader.Path, message, ex);
}
internal static JsonReaderException Create(IJsonLineInfo? lineInfo, string path, string message, Exception? ex)
{
message = JsonPosition.FormatMessage(lineInfo, path, message);
int lineNumber;
int linePosition;
if (lineInfo != null && lineInfo.HasLineInfo())
{
lineNumber = lineInfo.LineNumber;
linePosition = lineInfo.LinePosition;
}
else
{
lineNumber = 0;
linePosition = 0;
}
return new JsonReaderException(message, path, lineNumber, linePosition, ex);
}
}
}
================================================
FILE: Src/Newtonsoft.Json/JsonRequiredAttribute.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
using System.Collections.Generic;
using System.Text;
namespace Newtonsoft.Json
{
///
/// Instructs the to always serialize the member, and to require that the member has a value.
///
[AttributeUsage(AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = false)]
public sealed class JsonRequiredAttribute : Attribute
{
}
}
================================================
FILE: Src/Newtonsoft.Json/JsonSerializationException.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
using System.Collections.Generic;
using System.Runtime.Serialization;
using System.Text;
namespace Newtonsoft.Json
{
///
/// The exception thrown when an error occurs during JSON serialization or deserialization.
///
#if HAVE_BINARY_EXCEPTION_SERIALIZATION
[Serializable]
#endif
public class JsonSerializationException : JsonException
{
///
/// Gets the line number indicating where the error occurred.
///
/// The line number indicating where the error occurred.
public int LineNumber { get; }
///
/// Gets the line position indicating where the error occurred.
///
/// The line position indicating where the error occurred.
public int LinePosition { get; }
///
/// Gets the path to the JSON where the error occurred.
///
/// The path to the JSON where the error occurred.
public string? Path { get; }
///
/// Initializes a new instance of the class.
///
public JsonSerializationException()
{
}
///
/// Initializes a new instance of the class
/// with a specified error message.
///
/// The error message that explains the reason for the exception.
public JsonSerializationException(string message)
: base(message)
{
}
///
/// Initializes a new instance of the class
/// with a specified error message and a reference to the inner exception that is the cause of this exception.
///
/// The error message that explains the reason for the exception.
/// The exception that is the cause of the current exception, or null if no inner exception is specified.
public JsonSerializationException(string message, Exception innerException)
: base(message, innerException)
{
}
#if HAVE_BINARY_EXCEPTION_SERIALIZATION
///
/// Initializes a new instance of the class.
///
/// The that holds the serialized object data about the exception being thrown.
/// The that contains contextual information about the source or destination.
/// The parameter is null.
/// The class name is null or is zero (0).
public JsonSerializationException(SerializationInfo info, StreamingContext context)
: base(info, context)
{
}
#endif
///
/// Initializes a new instance of the class
/// with a specified error message, JSON path, line number, line position, and a reference to the inner exception that is the cause of this exception.
///
/// The error message that explains the reason for the exception.
/// The path to the JSON where the error occurred.
/// The line number indicating where the error occurred.
/// The line position indicating where the error occurred.
/// The exception that is the cause of the current exception, or null if no inner exception is specified.
public JsonSerializationException(string message, string path, int lineNumber, int linePosition, Exception? innerException)
: base(message, innerException)
{
Path = path;
LineNumber = lineNumber;
LinePosition = linePosition;
}
internal static JsonSerializationException Create(JsonReader reader, string message)
{
return Create(reader, message, null);
}
internal static JsonSerializationException Create(JsonReader reader, string message, Exception? ex)
{
return Create(reader as IJsonLineInfo, reader.Path, message, ex);
}
internal static JsonSerializationException Create(IJsonLineInfo? lineInfo, string path, string message, Exception? ex)
{
message = JsonPosition.FormatMessage(lineInfo, path, message);
int lineNumber;
int linePosition;
if (lineInfo != null && lineInfo.HasLineInfo())
{
lineNumber = lineInfo.LineNumber;
linePosition = lineInfo.LinePosition;
}
else
{
lineNumber = 0;
linePosition = 0;
}
return new JsonSerializationException(message, path, lineNumber, linePosition, ex);
}
}
}
================================================
FILE: Src/Newtonsoft.Json/JsonSerializer.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Runtime.Serialization.Formatters;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Serialization;
using Newtonsoft.Json.Utilities;
using System.Runtime.Serialization;
using ErrorEventArgs = Newtonsoft.Json.Serialization.ErrorEventArgs;
using System.Runtime.CompilerServices;
using System.Diagnostics.CodeAnalysis;
namespace Newtonsoft.Json
{
///
/// Serializes and deserializes objects into and from the JSON format.
/// The enables you to control how objects are encoded into JSON.
///
[RequiresUnreferencedCode(MiscellaneousUtils.TrimWarning)]
[RequiresDynamicCode(MiscellaneousUtils.AotWarning)]
public class JsonSerializer
{
internal TypeNameHandling _typeNameHandling;
internal TypeNameAssemblyFormatHandling _typeNameAssemblyFormatHandling;
internal PreserveReferencesHandling _preserveReferencesHandling;
internal ReferenceLoopHandling _referenceLoopHandling;
internal MissingMemberHandling _missingMemberHandling;
internal ObjectCreationHandling _objectCreationHandling;
internal NullValueHandling _nullValueHandling;
internal DefaultValueHandling _defaultValueHandling;
internal ConstructorHandling _constructorHandling;
internal MetadataPropertyHandling _metadataPropertyHandling;
internal JsonConverterCollection? _converters;
internal IContractResolver _contractResolver;
internal ITraceWriter? _traceWriter;
internal IEqualityComparer? _equalityComparer;
internal ISerializationBinder _serializationBinder;
internal StreamingContext _context;
private IReferenceResolver? _referenceResolver;
private Formatting? _formatting;
private DateFormatHandling? _dateFormatHandling;
private DateTimeZoneHandling? _dateTimeZoneHandling;
private DateParseHandling? _dateParseHandling;
private FloatFormatHandling? _floatFormatHandling;
private FloatParseHandling? _floatParseHandling;
private StringEscapeHandling? _stringEscapeHandling;
private CultureInfo _culture;
private int? _maxDepth;
private bool _maxDepthSet;
private bool? _checkAdditionalContent;
private string? _dateFormatString;
private bool _dateFormatStringSet;
///
/// Occurs when the errors during serialization and deserialization.
///
public virtual event EventHandler? Error;
///
/// Gets or sets the used by the serializer when resolving references.
///
public virtual IReferenceResolver? ReferenceResolver
{
get => GetReferenceResolver();
set
{
if (value == null)
{
throw new ArgumentNullException(nameof(value), "Reference resolver cannot be null.");
}
_referenceResolver = value;
}
}
///
/// Gets or sets the used by the serializer when resolving type names.
///
[Obsolete("Binder is obsolete. Use SerializationBinder instead.")]
public virtual SerializationBinder Binder
{
get
{
if (_serializationBinder is SerializationBinder legacySerializationBinder)
{
return legacySerializationBinder;
}
if (_serializationBinder is SerializationBinderAdapter adapter)
{
return adapter.SerializationBinder;
}
throw new InvalidOperationException("Cannot get SerializationBinder because an ISerializationBinder was previously set.");
}
set
{
if (value == null)
{
throw new ArgumentNullException(nameof(value), "Serialization binder cannot be null.");
}
_serializationBinder = value as ISerializationBinder ?? new SerializationBinderAdapter(value);
}
}
///
/// Gets or sets the used by the serializer when resolving type names.
///
public virtual ISerializationBinder SerializationBinder
{
get => _serializationBinder;
set
{
if (value == null)
{
throw new ArgumentNullException(nameof(value), "Serialization binder cannot be null.");
}
_serializationBinder = value;
}
}
///
/// Gets or sets the used by the serializer when writing trace messages.
///
/// The trace writer.
public virtual ITraceWriter? TraceWriter
{
get => _traceWriter;
set => _traceWriter = value;
}
///
/// Gets or sets the equality comparer used by the serializer when comparing references.
///
/// The equality comparer.
public virtual IEqualityComparer? EqualityComparer
{
get => _equalityComparer;
set => _equalityComparer = value;
}
///
/// Gets or sets how type name writing and reading is handled by the serializer.
/// The default value is .
///
///
/// should be used with caution when your application deserializes JSON from an external source.
/// Incoming types should be validated with a custom
/// when deserializing with a value other than .
///
public virtual TypeNameHandling TypeNameHandling
{
get => _typeNameHandling;
set
{
if (value < TypeNameHandling.None || value > TypeNameHandling.Auto)
{
throw new ArgumentOutOfRangeException(nameof(value));
}
_typeNameHandling = value;
}
}
///
/// Gets or sets how a type name assembly is written and resolved by the serializer.
/// The default value is .
///
/// The type name assembly format.
[Obsolete("TypeNameAssemblyFormat is obsolete. Use TypeNameAssemblyFormatHandling instead.")]
public virtual FormatterAssemblyStyle TypeNameAssemblyFormat
{
get => (FormatterAssemblyStyle)_typeNameAssemblyFormatHandling;
set
{
if (value < FormatterAssemblyStyle.Simple || value > FormatterAssemblyStyle.Full)
{
throw new ArgumentOutOfRangeException(nameof(value));
}
_typeNameAssemblyFormatHandling = (TypeNameAssemblyFormatHandling)value;
}
}
///
/// Gets or sets how a type name assembly is written and resolved by the serializer.
/// The default value is .
///
/// The type name assembly format.
public virtual TypeNameAssemblyFormatHandling TypeNameAssemblyFormatHandling
{
get => _typeNameAssemblyFormatHandling;
set
{
if (value < TypeNameAssemblyFormatHandling.Simple || value > TypeNameAssemblyFormatHandling.Full)
{
throw new ArgumentOutOfRangeException(nameof(value));
}
_typeNameAssemblyFormatHandling = value;
}
}
///
/// Gets or sets how object references are preserved by the serializer.
/// The default value is .
///
public virtual PreserveReferencesHandling PreserveReferencesHandling
{
get => _preserveReferencesHandling;
set
{
if (value < PreserveReferencesHandling.None || value > PreserveReferencesHandling.All)
{
throw new ArgumentOutOfRangeException(nameof(value));
}
_preserveReferencesHandling = value;
}
}
///
/// Gets or sets how reference loops (e.g. a class referencing itself) is handled.
/// The default value is .
///
public virtual ReferenceLoopHandling ReferenceLoopHandling
{
get => _referenceLoopHandling;
set
{
if (value < ReferenceLoopHandling.Error || value > ReferenceLoopHandling.Serialize)
{
throw new ArgumentOutOfRangeException(nameof(value));
}
_referenceLoopHandling = value;
}
}
///
/// Gets or sets how missing members (e.g. JSON contains a property that isn't a member on the object) are handled during deserialization.
/// The default value is .
///
public virtual MissingMemberHandling MissingMemberHandling
{
get => _missingMemberHandling;
set
{
if (value < MissingMemberHandling.Ignore || value > MissingMemberHandling.Error)
{
throw new ArgumentOutOfRangeException(nameof(value));
}
_missingMemberHandling = value;
}
}
///
/// Gets or sets how null values are handled during serialization and deserialization.
/// The default value is .
///
public virtual NullValueHandling NullValueHandling
{
get => _nullValueHandling;
set
{
if (value < NullValueHandling.Include || value > NullValueHandling.Ignore)
{
throw new ArgumentOutOfRangeException(nameof(value));
}
_nullValueHandling = value;
}
}
///
/// Gets or sets how default values are handled during serialization and deserialization.
/// The default value is .
///
public virtual DefaultValueHandling DefaultValueHandling
{
get => _defaultValueHandling;
set
{
if (value < DefaultValueHandling.Include || value > DefaultValueHandling.IgnoreAndPopulate)
{
throw new ArgumentOutOfRangeException(nameof(value));
}
_defaultValueHandling = value;
}
}
///
/// Gets or sets how objects are created during deserialization.
/// The default value is .
///
/// The object creation handling.
public virtual ObjectCreationHandling ObjectCreationHandling
{
get => _objectCreationHandling;
set
{
if (value < ObjectCreationHandling.Auto || value > ObjectCreationHandling.Replace)
{
throw new ArgumentOutOfRangeException(nameof(value));
}
_objectCreationHandling = value;
}
}
///
/// Gets or sets how constructors are used during deserialization.
/// The default value is .
///
/// The constructor handling.
public virtual ConstructorHandling ConstructorHandling
{
get => _constructorHandling;
set
{
if (value < ConstructorHandling.Default || value > ConstructorHandling.AllowNonPublicDefaultConstructor)
{
throw new ArgumentOutOfRangeException(nameof(value));
}
_constructorHandling = value;
}
}
///
/// Gets or sets how metadata properties are used during deserialization.
/// The default value is .
///
/// The metadata properties handling.
public virtual MetadataPropertyHandling MetadataPropertyHandling
{
get => _metadataPropertyHandling;
set
{
if (value < MetadataPropertyHandling.Default || value > MetadataPropertyHandling.Ignore)
{
throw new ArgumentOutOfRangeException(nameof(value));
}
_metadataPropertyHandling = value;
}
}
///
/// Gets a collection that will be used during serialization.
///
/// Collection that will be used during serialization.
public virtual JsonConverterCollection Converters
{
get
{
if (_converters == null)
{
_converters = new JsonConverterCollection();
}
return _converters;
}
}
///
/// Gets or sets the contract resolver used by the serializer when
/// serializing .NET objects to JSON and vice versa.
///
public virtual IContractResolver ContractResolver
{
get => _contractResolver;
set => _contractResolver = value ?? DefaultContractResolver.Instance;
}
///
/// Gets or sets the used by the serializer when invoking serialization callback methods.
///
/// The context.
public virtual StreamingContext Context
{
get => _context;
set => _context = value;
}
///
/// Indicates how JSON text output is formatted.
/// The default value is .
///
public virtual Formatting Formatting
{
get => _formatting ?? JsonSerializerSettings.DefaultFormatting;
set => _formatting = value;
}
///
/// Gets or sets how dates are written to JSON text.
/// The default value is .
///
public virtual DateFormatHandling DateFormatHandling
{
get => _dateFormatHandling ?? JsonSerializerSettings.DefaultDateFormatHandling;
set => _dateFormatHandling = value;
}
///
/// Gets or sets how time zones are handled during serialization and deserialization.
/// The default value is .
///
public virtual DateTimeZoneHandling DateTimeZoneHandling
{
get => _dateTimeZoneHandling ?? JsonSerializerSettings.DefaultDateTimeZoneHandling;
set => _dateTimeZoneHandling = value;
}
///
/// Gets or sets how date formatted strings, e.g. "\/Date(1198908717056)\/" and "2012-03-21T05:40Z", are parsed when reading JSON.
/// The default value is .
///
public virtual DateParseHandling DateParseHandling
{
get => _dateParseHandling ?? JsonSerializerSettings.DefaultDateParseHandling;
set => _dateParseHandling = value;
}
///
/// Gets or sets how floating point numbers, e.g. 1.0 and 9.9, are parsed when reading JSON text.
/// The default value is .
///
public virtual FloatParseHandling FloatParseHandling
{
get => _floatParseHandling ?? JsonSerializerSettings.DefaultFloatParseHandling;
set => _floatParseHandling = value;
}
///
/// Gets or sets how special floating point numbers, e.g. ,
/// and ,
/// are written as JSON text.
/// The default value is .
///
public virtual FloatFormatHandling FloatFormatHandling
{
get => _floatFormatHandling ?? JsonSerializerSettings.DefaultFloatFormatHandling;
set => _floatFormatHandling = value;
}
///
/// Gets or sets how strings are escaped when writing JSON text.
/// The default value is .
///
public virtual StringEscapeHandling StringEscapeHandling
{
get => _stringEscapeHandling ?? JsonSerializerSettings.DefaultStringEscapeHandling;
set => _stringEscapeHandling = value;
}
///
/// Gets or sets how and values are formatted when writing JSON text,
/// and the expected date format when reading JSON text.
/// The default value is "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK".
///
public virtual string DateFormatString
{
get => _dateFormatString ?? JsonSerializerSettings.DefaultDateFormatString;
set
{
_dateFormatString = value;
_dateFormatStringSet = true;
}
}
///
/// Gets or sets the culture used when reading JSON.
/// The default value is .
///
public virtual CultureInfo Culture
{
get => _culture ?? JsonSerializerSettings.DefaultCulture;
set => _culture = value;
}
///
/// Gets or sets the maximum depth allowed when reading JSON. Reading past this depth will throw a .
/// A null value means there is no maximum.
/// The default value is 64.
///
public virtual int? MaxDepth
{
get => _maxDepth;
set
{
if (value <= 0)
{
throw new ArgumentException("Value must be positive.", nameof(value));
}
_maxDepth = value;
_maxDepthSet = true;
}
}
///
/// Gets a value indicating whether there will be a check for additional JSON content after deserializing an object.
/// The default value is false.
///
///
/// true if there will be a check for additional JSON content after deserializing an object; otherwise, false.
///
public virtual bool CheckAdditionalContent
{
get => _checkAdditionalContent ?? JsonSerializerSettings.DefaultCheckAdditionalContent;
set => _checkAdditionalContent = value;
}
internal bool IsCheckAdditionalContentSet()
{
return (_checkAdditionalContent != null);
}
///
/// Initializes a new instance of the class.
///
public JsonSerializer()
{
_referenceLoopHandling = JsonSerializerSettings.DefaultReferenceLoopHandling;
_missingMemberHandling = JsonSerializerSettings.DefaultMissingMemberHandling;
_nullValueHandling = JsonSerializerSettings.DefaultNullValueHandling;
_defaultValueHandling = JsonSerializerSettings.DefaultDefaultValueHandling;
_objectCreationHandling = JsonSerializerSettings.DefaultObjectCreationHandling;
_preserveReferencesHandling = JsonSerializerSettings.DefaultPreserveReferencesHandling;
_constructorHandling = JsonSerializerSettings.DefaultConstructorHandling;
_typeNameHandling = JsonSerializerSettings.DefaultTypeNameHandling;
_metadataPropertyHandling = JsonSerializerSettings.DefaultMetadataPropertyHandling;
_context = JsonSerializerSettings.DefaultContext;
_serializationBinder = DefaultSerializationBinder.Instance;
_culture = JsonSerializerSettings.DefaultCulture;
_contractResolver = DefaultContractResolver.Instance;
}
///
/// Creates a new instance.
/// The will not use default settings
/// from .
///
///
/// A new instance.
/// The will not use default settings
/// from .
///
public static JsonSerializer Create()
{
return new JsonSerializer();
}
///
/// Creates a new instance using the specified .
/// The will not use default settings
/// from .
///
/// The settings to be applied to the .
///
/// A new instance using the specified .
/// The will not use default settings
/// from .
///
public static JsonSerializer Create(JsonSerializerSettings? settings)
{
JsonSerializer serializer = Create();
if (settings != null)
{
ApplySerializerSettings(serializer, settings);
}
return serializer;
}
///
/// Creates a new instance.
/// The will use default settings
/// from .
///
///
/// A new instance.
/// The will use default settings
/// from .
///
public static JsonSerializer CreateDefault()
{
// copy static to local variable to avoid concurrency issues
JsonSerializerSettings? defaultSettings = JsonConvert.DefaultSettings?.Invoke();
return Create(defaultSettings);
}
///
/// Creates a new instance using the specified .
/// The will use default settings
/// from as well as the specified .
///
/// The settings to be applied to the .
///
/// A new instance using the specified .
/// The will use default settings
/// from as well as the specified .
///
public static JsonSerializer CreateDefault(JsonSerializerSettings? settings)
{
JsonSerializer serializer = CreateDefault();
if (settings != null)
{
ApplySerializerSettings(serializer, settings);
}
return serializer;
}
private static void ApplySerializerSettings(JsonSerializer serializer, JsonSerializerSettings settings)
{
if (!CollectionUtils.IsNullOrEmpty(settings.Converters))
{
// insert settings converters at the beginning so they take precedence
// if user wants to remove one of the default converters they will have to do it manually
for (int i = 0; i < settings.Converters.Count; i++)
{
serializer.Converters.Insert(i, settings.Converters[i]);
}
}
// serializer specific
if (settings._typeNameHandling != null)
{
serializer.TypeNameHandling = settings.TypeNameHandling;
}
if (settings._metadataPropertyHandling != null)
{
serializer.MetadataPropertyHandling = settings.MetadataPropertyHandling;
}
if (settings._typeNameAssemblyFormatHandling != null)
{
serializer.TypeNameAssemblyFormatHandling = settings.TypeNameAssemblyFormatHandling;
}
if (settings._preserveReferencesHandling != null)
{
serializer.PreserveReferencesHandling = settings.PreserveReferencesHandling;
}
if (settings._referenceLoopHandling != null)
{
serializer.ReferenceLoopHandling = settings.ReferenceLoopHandling;
}
if (settings._missingMemberHandling != null)
{
serializer.MissingMemberHandling = settings.MissingMemberHandling;
}
if (settings._objectCreationHandling != null)
{
serializer.ObjectCreationHandling = settings.ObjectCreationHandling;
}
if (settings._nullValueHandling != null)
{
serializer.NullValueHandling = settings.NullValueHandling;
}
if (settings._defaultValueHandling != null)
{
serializer.DefaultValueHandling = settings.DefaultValueHandling;
}
if (settings._constructorHandling != null)
{
serializer.ConstructorHandling = settings.ConstructorHandling;
}
if (settings._context != null)
{
serializer.Context = settings.Context;
}
if (settings._checkAdditionalContent != null)
{
serializer._checkAdditionalContent = settings._checkAdditionalContent;
}
if (settings.Error != null)
{
serializer.Error += settings.Error;
}
if (settings.ContractResolver != null)
{
serializer.ContractResolver = settings.ContractResolver;
}
if (settings.ReferenceResolverProvider != null)
{
serializer.ReferenceResolver = settings.ReferenceResolverProvider();
}
if (settings.TraceWriter != null)
{
serializer.TraceWriter = settings.TraceWriter;
}
if (settings.EqualityComparer != null)
{
serializer.EqualityComparer = settings.EqualityComparer;
}
if (settings.SerializationBinder != null)
{
serializer.SerializationBinder = settings.SerializationBinder;
}
// reader/writer specific
// unset values won't override reader/writer set values
if (settings._formatting != null)
{
serializer._formatting = settings._formatting;
}
if (settings._dateFormatHandling != null)
{
serializer._dateFormatHandling = settings._dateFormatHandling;
}
if (settings._dateTimeZoneHandling != null)
{
serializer._dateTimeZoneHandling = settings._dateTimeZoneHandling;
}
if (settings._dateParseHandling != null)
{
serializer._dateParseHandling = settings._dateParseHandling;
}
if (settings._dateFormatStringSet)
{
serializer._dateFormatString = settings._dateFormatString;
serializer._dateFormatStringSet = settings._dateFormatStringSet;
}
if (settings._floatFormatHandling != null)
{
serializer._floatFormatHandling = settings._floatFormatHandling;
}
if (settings._floatParseHandling != null)
{
serializer._floatParseHandling = settings._floatParseHandling;
}
if (settings._stringEscapeHandling != null)
{
serializer._stringEscapeHandling = settings._stringEscapeHandling;
}
if (settings._culture != null)
{
serializer._culture = settings._culture;
}
if (settings._maxDepthSet)
{
serializer._maxDepth = settings._maxDepth;
serializer._maxDepthSet = settings._maxDepthSet;
}
}
///
/// Populates the JSON values onto the target object.
///
/// The that contains the JSON structure to read values from.
/// The target object to populate values onto.
[DebuggerStepThrough]
public void Populate(TextReader reader, object target)
{
Populate(new JsonTextReader(reader), target);
}
///
/// Populates the JSON values onto the target object.
///
/// The that contains the JSON structure to read values from.
/// The target object to populate values onto.
[DebuggerStepThrough]
public void Populate(JsonReader reader, object target)
{
PopulateInternal(reader, target);
}
internal virtual void PopulateInternal(JsonReader reader, object target)
{
ValidationUtils.ArgumentNotNull(reader, nameof(reader));
ValidationUtils.ArgumentNotNull(target, nameof(target));
SetupReader(
reader,
out CultureInfo? previousCulture,
out DateTimeZoneHandling? previousDateTimeZoneHandling,
out DateParseHandling? previousDateParseHandling,
out FloatParseHandling? previousFloatParseHandling,
out int? previousMaxDepth,
out string? previousDateFormatString);
TraceJsonReader? traceJsonReader = (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose)
? CreateTraceJsonReader(reader)
: null;
JsonSerializerInternalReader serializerReader = new JsonSerializerInternalReader(this);
serializerReader.Populate(traceJsonReader ?? reader, target);
if (traceJsonReader != null)
{
TraceWriter!.Trace(TraceLevel.Verbose, traceJsonReader.GetDeserializedJsonMessage(), null);
}
ResetReader(reader, previousCulture, previousDateTimeZoneHandling, previousDateParseHandling, previousFloatParseHandling, previousMaxDepth, previousDateFormatString);
}
///
/// Deserializes the JSON structure contained by the specified .
///
/// The that contains the JSON structure to deserialize.
/// The being deserialized.
[DebuggerStepThrough]
public object? Deserialize(JsonReader reader)
{
return Deserialize(reader, null);
}
///
/// Deserializes the JSON structure contained by the specified
/// into an instance of the specified type.
///
/// The containing the object.
/// The of object being deserialized.
/// The instance of being deserialized.
[DebuggerStepThrough]
public object? Deserialize(TextReader reader, Type objectType)
{
return Deserialize(new JsonTextReader(reader), objectType);
}
///
/// Deserializes the JSON structure contained by the specified
/// into an instance of the specified type.
///
/// The containing the object.
/// The type of the object to deserialize.
/// The instance of being deserialized.
[DebuggerStepThrough]
public T? Deserialize(JsonReader reader)
{
return (T?)Deserialize(reader, typeof(T));
}
///
/// Deserializes the JSON structure contained by the specified
/// into an instance of the specified type.
///
/// The containing the object.
/// The of object being deserialized.
/// The instance of being deserialized.
[DebuggerStepThrough]
public object? Deserialize(JsonReader reader, Type? objectType)
{
return DeserializeInternal(reader, objectType);
}
internal virtual object? DeserializeInternal(JsonReader reader, Type? objectType)
{
ValidationUtils.ArgumentNotNull(reader, nameof(reader));
SetupReader(
reader,
out CultureInfo? previousCulture,
out DateTimeZoneHandling? previousDateTimeZoneHandling,
out DateParseHandling? previousDateParseHandling,
out FloatParseHandling? previousFloatParseHandling,
out int? previousMaxDepth,
out string? previousDateFormatString);
TraceJsonReader? traceJsonReader = (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose)
? CreateTraceJsonReader(reader)
: null;
JsonSerializerInternalReader serializerReader = new JsonSerializerInternalReader(this);
object? value = serializerReader.Deserialize(traceJsonReader ?? reader, objectType, CheckAdditionalContent);
if (traceJsonReader != null)
{
TraceWriter!.Trace(TraceLevel.Verbose, traceJsonReader.GetDeserializedJsonMessage(), null);
}
ResetReader(reader, previousCulture, previousDateTimeZoneHandling, previousDateParseHandling, previousFloatParseHandling, previousMaxDepth, previousDateFormatString);
return value;
}
internal void SetupReader(JsonReader reader, out CultureInfo? previousCulture, out DateTimeZoneHandling? previousDateTimeZoneHandling, out DateParseHandling? previousDateParseHandling, out FloatParseHandling? previousFloatParseHandling, out int? previousMaxDepth, out string? previousDateFormatString)
{
if (_culture != null && !_culture.Equals(reader.Culture))
{
previousCulture = reader.Culture;
reader.Culture = _culture;
}
else
{
previousCulture = null;
}
if (_dateTimeZoneHandling != null && reader.DateTimeZoneHandling != _dateTimeZoneHandling)
{
previousDateTimeZoneHandling = reader.DateTimeZoneHandling;
reader.DateTimeZoneHandling = _dateTimeZoneHandling.GetValueOrDefault();
}
else
{
previousDateTimeZoneHandling = null;
}
if (_dateParseHandling != null && reader.DateParseHandling != _dateParseHandling)
{
previousDateParseHandling = reader.DateParseHandling;
reader.DateParseHandling = _dateParseHandling.GetValueOrDefault();
}
else
{
previousDateParseHandling = null;
}
if (_floatParseHandling != null && reader.FloatParseHandling != _floatParseHandling)
{
previousFloatParseHandling = reader.FloatParseHandling;
reader.FloatParseHandling = _floatParseHandling.GetValueOrDefault();
}
else
{
previousFloatParseHandling = null;
}
if (_maxDepthSet && reader.MaxDepth != _maxDepth)
{
previousMaxDepth = reader.MaxDepth;
reader.MaxDepth = _maxDepth;
}
else
{
previousMaxDepth = null;
}
if (_dateFormatStringSet && reader.DateFormatString != _dateFormatString)
{
previousDateFormatString = reader.DateFormatString;
reader.DateFormatString = _dateFormatString;
}
else
{
previousDateFormatString = null;
}
if (reader is JsonTextReader textReader)
{
if (textReader.PropertyNameTable == null && _contractResolver is DefaultContractResolver resolver)
{
textReader.PropertyNameTable = resolver.GetNameTable();
}
}
}
private void ResetReader(JsonReader reader, CultureInfo? previousCulture, DateTimeZoneHandling? previousDateTimeZoneHandling, DateParseHandling? previousDateParseHandling, FloatParseHandling? previousFloatParseHandling, int? previousMaxDepth, string? previousDateFormatString)
{
// reset reader back to previous options
if (previousCulture != null)
{
reader.Culture = previousCulture;
}
if (previousDateTimeZoneHandling != null)
{
reader.DateTimeZoneHandling = previousDateTimeZoneHandling.GetValueOrDefault();
}
if (previousDateParseHandling != null)
{
reader.DateParseHandling = previousDateParseHandling.GetValueOrDefault();
}
if (previousFloatParseHandling != null)
{
reader.FloatParseHandling = previousFloatParseHandling.GetValueOrDefault();
}
if (_maxDepthSet)
{
reader.MaxDepth = previousMaxDepth;
}
if (_dateFormatStringSet)
{
reader.DateFormatString = previousDateFormatString;
}
if (reader is JsonTextReader textReader && textReader.PropertyNameTable != null &&
_contractResolver is DefaultContractResolver resolver && textReader.PropertyNameTable == resolver.GetNameTable())
{
textReader.PropertyNameTable = null;
}
}
///
/// Serializes the specified and writes the JSON structure
/// using the specified .
///
/// The used to write the JSON structure.
/// The to serialize.
public void Serialize(TextWriter textWriter, object? value)
{
Serialize(new JsonTextWriter(textWriter), value);
}
///
/// Serializes the specified and writes the JSON structure
/// using the specified .
///
/// The used to write the JSON structure.
/// The to serialize.
///
/// The type of the value being serialized.
/// This parameter is used when is to write out the type name if the type of the value does not match.
/// Specifying the type is optional.
///
public void Serialize(JsonWriter jsonWriter, object? value, Type? objectType)
{
SerializeInternal(jsonWriter, value, objectType);
}
///
/// Serializes the specified and writes the JSON structure
/// using the specified .
///
/// The used to write the JSON structure.
/// The to serialize.
///
/// The type of the value being serialized.
/// This parameter is used when is Auto to write out the type name if the type of the value does not match.
/// Specifying the type is optional.
///
public void Serialize(TextWriter textWriter, object? value, Type objectType)
{
Serialize(new JsonTextWriter(textWriter), value, objectType);
}
///
/// Serializes the specified and writes the JSON structure
/// using the specified .
///
/// The used to write the JSON structure.
/// The to serialize.
public void Serialize(JsonWriter jsonWriter, object? value)
{
SerializeInternal(jsonWriter, value, null);
}
private TraceJsonReader CreateTraceJsonReader(JsonReader reader)
{
TraceJsonReader traceReader = new TraceJsonReader(reader);
if (reader.TokenType != JsonToken.None)
{
traceReader.WriteCurrentToken();
}
return traceReader;
}
internal virtual void SerializeInternal(JsonWriter jsonWriter, object? value, Type? objectType)
{
ValidationUtils.ArgumentNotNull(jsonWriter, nameof(jsonWriter));
// set serialization options onto writer
Formatting? previousFormatting = null;
if (_formatting != null && jsonWriter.Formatting != _formatting)
{
previousFormatting = jsonWriter.Formatting;
jsonWriter.Formatting = _formatting.GetValueOrDefault();
}
DateFormatHandling? previousDateFormatHandling = null;
if (_dateFormatHandling != null && jsonWriter.DateFormatHandling != _dateFormatHandling)
{
previousDateFormatHandling = jsonWriter.DateFormatHandling;
jsonWriter.DateFormatHandling = _dateFormatHandling.GetValueOrDefault();
}
DateTimeZoneHandling? previousDateTimeZoneHandling = null;
if (_dateTimeZoneHandling != null && jsonWriter.DateTimeZoneHandling != _dateTimeZoneHandling)
{
previousDateTimeZoneHandling = jsonWriter.DateTimeZoneHandling;
jsonWriter.DateTimeZoneHandling = _dateTimeZoneHandling.GetValueOrDefault();
}
FloatFormatHandling? previousFloatFormatHandling = null;
if (_floatFormatHandling != null && jsonWriter.FloatFormatHandling != _floatFormatHandling)
{
previousFloatFormatHandling = jsonWriter.FloatFormatHandling;
jsonWriter.FloatFormatHandling = _floatFormatHandling.GetValueOrDefault();
}
StringEscapeHandling? previousStringEscapeHandling = null;
if (_stringEscapeHandling != null && jsonWriter.StringEscapeHandling != _stringEscapeHandling)
{
previousStringEscapeHandling = jsonWriter.StringEscapeHandling;
jsonWriter.StringEscapeHandling = _stringEscapeHandling.GetValueOrDefault();
}
CultureInfo? previousCulture = null;
if (_culture != null && !_culture.Equals(jsonWriter.Culture))
{
previousCulture = jsonWriter.Culture;
jsonWriter.Culture = _culture;
}
string? previousDateFormatString = null;
if (_dateFormatStringSet && jsonWriter.DateFormatString != _dateFormatString)
{
previousDateFormatString = jsonWriter.DateFormatString;
jsonWriter.DateFormatString = _dateFormatString;
}
TraceJsonWriter? traceJsonWriter = (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose)
? new TraceJsonWriter(jsonWriter)
: null;
JsonSerializerInternalWriter serializerWriter = new JsonSerializerInternalWriter(this);
serializerWriter.Serialize(traceJsonWriter ?? jsonWriter, value, objectType);
if (traceJsonWriter != null)
{
TraceWriter!.Trace(TraceLevel.Verbose, traceJsonWriter.GetSerializedJsonMessage(), null);
}
// reset writer back to previous options
if (previousFormatting != null)
{
jsonWriter.Formatting = previousFormatting.GetValueOrDefault();
}
if (previousDateFormatHandling != null)
{
jsonWriter.DateFormatHandling = previousDateFormatHandling.GetValueOrDefault();
}
if (previousDateTimeZoneHandling != null)
{
jsonWriter.DateTimeZoneHandling = previousDateTimeZoneHandling.GetValueOrDefault();
}
if (previousFloatFormatHandling != null)
{
jsonWriter.FloatFormatHandling = previousFloatFormatHandling.GetValueOrDefault();
}
if (previousStringEscapeHandling != null)
{
jsonWriter.StringEscapeHandling = previousStringEscapeHandling.GetValueOrDefault();
}
if (_dateFormatStringSet)
{
jsonWriter.DateFormatString = previousDateFormatString;
}
if (previousCulture != null)
{
jsonWriter.Culture = previousCulture;
}
}
internal IReferenceResolver GetReferenceResolver()
{
if (_referenceResolver == null)
{
_referenceResolver = new DefaultReferenceResolver();
}
return _referenceResolver;
}
internal JsonConverter? GetMatchingConverter(Type type)
{
return GetMatchingConverter(_converters, type);
}
internal static JsonConverter? GetMatchingConverter(IList? converters, Type objectType)
{
#if DEBUG
ValidationUtils.ArgumentNotNull(objectType, nameof(objectType));
#endif
if (converters != null)
{
for (int i = 0; i < converters.Count; i++)
{
JsonConverter converter = converters[i];
if (converter.CanConvert(objectType))
{
return converter;
}
}
}
return null;
}
internal void OnError(ErrorEventArgs e)
{
Error?.Invoke(this, e);
}
}
}
================================================
FILE: Src/Newtonsoft.Json/JsonSerializerSettings.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Runtime.Serialization.Formatters;
using Newtonsoft.Json.Serialization;
using System.Runtime.Serialization;
using System.Diagnostics;
using System.Runtime;
#if !HAVE_LINQ
using Newtonsoft.Json.Utilities.LinqBridge;
#else
using System.Linq;
#endif
namespace Newtonsoft.Json
{
///
/// Specifies the settings on a object.
///
public class JsonSerializerSettings
{
internal const ReferenceLoopHandling DefaultReferenceLoopHandling = ReferenceLoopHandling.Error;
internal const MissingMemberHandling DefaultMissingMemberHandling = MissingMemberHandling.Ignore;
internal const NullValueHandling DefaultNullValueHandling = NullValueHandling.Include;
internal const DefaultValueHandling DefaultDefaultValueHandling = DefaultValueHandling.Include;
internal const ObjectCreationHandling DefaultObjectCreationHandling = ObjectCreationHandling.Auto;
internal const PreserveReferencesHandling DefaultPreserveReferencesHandling = PreserveReferencesHandling.None;
internal const ConstructorHandling DefaultConstructorHandling = ConstructorHandling.Default;
internal const TypeNameHandling DefaultTypeNameHandling = TypeNameHandling.None;
internal const MetadataPropertyHandling DefaultMetadataPropertyHandling = MetadataPropertyHandling.Default;
internal static readonly StreamingContext DefaultContext;
internal const Formatting DefaultFormatting = Formatting.None;
internal const DateFormatHandling DefaultDateFormatHandling = DateFormatHandling.IsoDateFormat;
internal const DateTimeZoneHandling DefaultDateTimeZoneHandling = DateTimeZoneHandling.RoundtripKind;
internal const DateParseHandling DefaultDateParseHandling = DateParseHandling.DateTime;
internal const FloatParseHandling DefaultFloatParseHandling = FloatParseHandling.Double;
internal const FloatFormatHandling DefaultFloatFormatHandling = FloatFormatHandling.String;
internal const StringEscapeHandling DefaultStringEscapeHandling = StringEscapeHandling.Default;
internal const TypeNameAssemblyFormatHandling DefaultTypeNameAssemblyFormatHandling = TypeNameAssemblyFormatHandling.Simple;
internal static readonly CultureInfo DefaultCulture;
internal const bool DefaultCheckAdditionalContent = false;
internal const string DefaultDateFormatString = @"yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK";
internal const int DefaultMaxDepth = 64;
internal Formatting? _formatting;
internal DateFormatHandling? _dateFormatHandling;
internal DateTimeZoneHandling? _dateTimeZoneHandling;
internal DateParseHandling? _dateParseHandling;
internal FloatFormatHandling? _floatFormatHandling;
internal FloatParseHandling? _floatParseHandling;
internal StringEscapeHandling? _stringEscapeHandling;
internal CultureInfo? _culture;
internal bool? _checkAdditionalContent;
internal int? _maxDepth;
internal bool _maxDepthSet;
internal string? _dateFormatString;
internal bool _dateFormatStringSet;
internal TypeNameAssemblyFormatHandling? _typeNameAssemblyFormatHandling;
internal DefaultValueHandling? _defaultValueHandling;
internal PreserveReferencesHandling? _preserveReferencesHandling;
internal NullValueHandling? _nullValueHandling;
internal ObjectCreationHandling? _objectCreationHandling;
internal MissingMemberHandling? _missingMemberHandling;
internal ReferenceLoopHandling? _referenceLoopHandling;
internal StreamingContext? _context;
internal ConstructorHandling? _constructorHandling;
internal TypeNameHandling? _typeNameHandling;
internal MetadataPropertyHandling? _metadataPropertyHandling;
///
/// Gets or sets how reference loops (e.g. a class referencing itself) are handled.
/// The default value is .
///
/// Reference loop handling.
public ReferenceLoopHandling ReferenceLoopHandling
{
get => _referenceLoopHandling ?? DefaultReferenceLoopHandling;
set => _referenceLoopHandling = value;
}
///
/// Gets or sets how missing members (e.g. JSON contains a property that isn't a member on the object) are handled during deserialization.
/// The default value is .
///
/// Missing member handling.
public MissingMemberHandling MissingMemberHandling
{
get => _missingMemberHandling ?? DefaultMissingMemberHandling;
set => _missingMemberHandling = value;
}
///
/// Gets or sets how objects are created during deserialization.
/// The default value is .
///
/// The object creation handling.
public ObjectCreationHandling ObjectCreationHandling
{
get => _objectCreationHandling ?? DefaultObjectCreationHandling;
set => _objectCreationHandling = value;
}
///
/// Gets or sets how null values are handled during serialization and deserialization.
/// The default value is .
///
/// Null value handling.
public NullValueHandling NullValueHandling
{
get => _nullValueHandling ?? DefaultNullValueHandling;
set => _nullValueHandling = value;
}
///
/// Gets or sets how default values are handled during serialization and deserialization.
/// The default value is .
///
/// The default value handling.
public DefaultValueHandling DefaultValueHandling
{
get => _defaultValueHandling ?? DefaultDefaultValueHandling;
set => _defaultValueHandling = value;
}
///
/// Gets or sets a collection that will be used during serialization.
///
/// The converters.
public IList Converters { get; set; }
///
/// Gets or sets how object references are preserved by the serializer.
/// The default value is .
///
/// The preserve references handling.
public PreserveReferencesHandling PreserveReferencesHandling
{
get => _preserveReferencesHandling ?? DefaultPreserveReferencesHandling;
set => _preserveReferencesHandling = value;
}
///
/// Gets or sets how type name writing and reading is handled by the serializer.
/// The default value is .
///
///
/// should be used with caution when your application deserializes JSON from an external source.
/// Incoming types should be validated with a custom
/// when deserializing with a value other than .
///
/// The type name handling.
public TypeNameHandling TypeNameHandling
{
get => _typeNameHandling ?? DefaultTypeNameHandling;
set => _typeNameHandling = value;
}
///
/// Gets or sets how metadata properties are used during deserialization.
/// The default value is .
///
/// The metadata properties handling.
public MetadataPropertyHandling MetadataPropertyHandling
{
get => _metadataPropertyHandling ?? DefaultMetadataPropertyHandling;
set => _metadataPropertyHandling = value;
}
///
/// Gets or sets how a type name assembly is written and resolved by the serializer.
/// The default value is .
///
/// The type name assembly format.
[Obsolete("TypeNameAssemblyFormat is obsolete. Use TypeNameAssemblyFormatHandling instead.")]
public FormatterAssemblyStyle TypeNameAssemblyFormat
{
get => (FormatterAssemblyStyle)TypeNameAssemblyFormatHandling;
set => TypeNameAssemblyFormatHandling = (TypeNameAssemblyFormatHandling)value;
}
///
/// Gets or sets how a type name assembly is written and resolved by the serializer.
/// The default value is .
///
/// The type name assembly format.
public TypeNameAssemblyFormatHandling TypeNameAssemblyFormatHandling
{
get => _typeNameAssemblyFormatHandling ?? DefaultTypeNameAssemblyFormatHandling;
set => _typeNameAssemblyFormatHandling = value;
}
///
/// Gets or sets how constructors are used during deserialization.
/// The default value is .
///
/// The constructor handling.
public ConstructorHandling ConstructorHandling
{
get => _constructorHandling ?? DefaultConstructorHandling;
set => _constructorHandling = value;
}
///
/// Gets or sets the contract resolver used by the serializer when
/// serializing .NET objects to JSON and vice versa.
///
/// The contract resolver.
public IContractResolver? ContractResolver { get; set; }
///
/// Gets or sets the equality comparer used by the serializer when comparing references.
///
/// The equality comparer.
public IEqualityComparer? EqualityComparer { get; set; }
///
/// Gets or sets the used by the serializer when resolving references.
///
/// The reference resolver.
[Obsolete("ReferenceResolver property is obsolete. Use the ReferenceResolverProvider property to set the IReferenceResolver: settings.ReferenceResolverProvider = () => resolver")]
public IReferenceResolver? ReferenceResolver
{
get => ReferenceResolverProvider?.Invoke();
set
{
ReferenceResolverProvider = (value != null)
? () => value
: (Func?)null;
}
}
///
/// Gets or sets a function that creates the used by the serializer when resolving references.
///
/// A function that creates the used by the serializer when resolving references.
public Func? ReferenceResolverProvider { get; set; }
///
/// Gets or sets the used by the serializer when writing trace messages.
///
/// The trace writer.
public ITraceWriter? TraceWriter { get; set; }
///
/// Gets or sets the used by the serializer when resolving type names.
///
/// The binder.
[Obsolete("Binder is obsolete. Use SerializationBinder instead.")]
public SerializationBinder? Binder
{
get
{
if (SerializationBinder == null)
{
return null;
}
if (SerializationBinder is SerializationBinderAdapter adapter)
{
return adapter.SerializationBinder;
}
throw new InvalidOperationException("Cannot get SerializationBinder because an ISerializationBinder was previously set.");
}
set => SerializationBinder = value == null ? null : new SerializationBinderAdapter(value);
}
///
/// Gets or sets the used by the serializer when resolving type names.
///
/// The binder.
public ISerializationBinder? SerializationBinder { get; set; }
///
/// Gets or sets the error handler called during serialization and deserialization.
///
/// The error handler called during serialization and deserialization.
public EventHandler? Error { get; set; }
///
/// Gets or sets the used by the serializer when invoking serialization callback methods.
///
/// The context.
public StreamingContext Context
{
get => _context ?? DefaultContext;
set => _context = value;
}
///
/// Gets or sets how and values are formatted when writing JSON text,
/// and the expected date format when reading JSON text.
/// The default value is "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK".
///
public string DateFormatString
{
get => _dateFormatString ?? DefaultDateFormatString;
set
{
_dateFormatString = value;
_dateFormatStringSet = true;
}
}
///
/// Gets or sets the maximum depth allowed when reading JSON. Reading past this depth will throw a .
/// A null value means there is no maximum.
/// The default value is 64.
///
public int? MaxDepth
{
get => _maxDepthSet ? _maxDepth : DefaultMaxDepth;
set
{
if (value <= 0)
{
throw new ArgumentException("Value must be positive.", nameof(value));
}
_maxDepth = value;
_maxDepthSet = true;
}
}
///
/// Indicates how JSON text output is formatted.
/// The default value is .
///
public Formatting Formatting
{
get => _formatting ?? DefaultFormatting;
set => _formatting = value;
}
///
/// Gets or sets how dates are written to JSON text.
/// The default value is .
///
public DateFormatHandling DateFormatHandling
{
get => _dateFormatHandling ?? DefaultDateFormatHandling;
set => _dateFormatHandling = value;
}
///
/// Gets or sets how time zones are handled during serialization and deserialization.
/// The default value is .
///
public DateTimeZoneHandling DateTimeZoneHandling
{
get => _dateTimeZoneHandling ?? DefaultDateTimeZoneHandling;
set => _dateTimeZoneHandling = value;
}
///
/// Gets or sets how date formatted strings, e.g. "\/Date(1198908717056)\/" and "2012-03-21T05:40Z", are parsed when reading JSON.
/// The default value is .
///
public DateParseHandling DateParseHandling
{
get => _dateParseHandling ?? DefaultDateParseHandling;
set => _dateParseHandling = value;
}
///
/// Gets or sets how special floating point numbers, e.g. ,
/// and ,
/// are written as JSON.
/// The default value is .
///
public FloatFormatHandling FloatFormatHandling
{
get => _floatFormatHandling ?? DefaultFloatFormatHandling;
set => _floatFormatHandling = value;
}
///
/// Gets or sets how floating point numbers, e.g. 1.0 and 9.9, are parsed when reading JSON text.
/// The default value is .
///
public FloatParseHandling FloatParseHandling
{
get => _floatParseHandling ?? DefaultFloatParseHandling;
set => _floatParseHandling = value;
}
///
/// Gets or sets how strings are escaped when writing JSON text.
/// The default value is .
///
public StringEscapeHandling StringEscapeHandling
{
get => _stringEscapeHandling ?? DefaultStringEscapeHandling;
set => _stringEscapeHandling = value;
}
///
/// Gets or sets the culture used when reading JSON.
/// The default value is .
///
public CultureInfo Culture
{
get => _culture ?? DefaultCulture;
set => _culture = value;
}
///
/// Gets a value indicating whether there will be a check for additional content after deserializing an object.
/// The default value is false.
///
///
/// true if there will be a check for additional content after deserializing an object; otherwise, false.
///
public bool CheckAdditionalContent
{
get => _checkAdditionalContent ?? DefaultCheckAdditionalContent;
set => _checkAdditionalContent = value;
}
static JsonSerializerSettings()
{
DefaultContext = new StreamingContext();
DefaultCulture = CultureInfo.InvariantCulture;
}
///
/// Initializes a new instance of the class.
///
[DebuggerStepThrough]
public JsonSerializerSettings()
{
Converters = new List();
}
///
/// Initializes a new instance of the class
/// using values copied from the passed in .
///
public JsonSerializerSettings(JsonSerializerSettings original)
{
_floatParseHandling = original._floatParseHandling;
_floatFormatHandling = original._floatFormatHandling;
_dateParseHandling = original._dateParseHandling;
_dateTimeZoneHandling = original._dateTimeZoneHandling;
_dateFormatHandling = original._dateFormatHandling;
_formatting = original._formatting;
_maxDepth = original._maxDepth;
_maxDepthSet = original._maxDepthSet;
_dateFormatString = original._dateFormatString;
_dateFormatStringSet = original._dateFormatStringSet;
_context = original._context;
Error = original.Error;
SerializationBinder = original.SerializationBinder;
TraceWriter = original.TraceWriter;
_culture = original._culture;
ReferenceResolverProvider = original.ReferenceResolverProvider;
EqualityComparer = original.EqualityComparer;
ContractResolver = original.ContractResolver;
_constructorHandling = original._constructorHandling;
_typeNameAssemblyFormatHandling = original._typeNameAssemblyFormatHandling;
_metadataPropertyHandling = original._metadataPropertyHandling;
_typeNameHandling = original._typeNameHandling;
_preserveReferencesHandling = original._preserveReferencesHandling;
Converters = original.Converters.ToList();
_defaultValueHandling = original._defaultValueHandling;
_nullValueHandling = original._nullValueHandling;
_objectCreationHandling = original._objectCreationHandling;
_missingMemberHandling = original._missingMemberHandling;
_referenceLoopHandling = original._referenceLoopHandling;
_checkAdditionalContent = original._checkAdditionalContent;
_stringEscapeHandling = original._stringEscapeHandling;
}
}
}
================================================
FILE: Src/Newtonsoft.Json/JsonTextReader.Async.cs
================================================
#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion
#if HAVE_ASYNC
using System;
using System.Globalization;
using System.Threading;
#if HAVE_BIG_INTEGER
using System.Numerics;
#endif
using System.Threading.Tasks;
using Newtonsoft.Json.Serialization;
using Newtonsoft.Json.Utilities;
using System.Diagnostics;
namespace Newtonsoft.Json
{
public partial class JsonTextReader
{
// It's not safe to perform the async methods here in a derived class as if the synchronous equivalent
// has been overriden then the asychronous method will no longer be doing the same operation
#if HAVE_ASYNC // Double-check this isn't included inappropriately.
private readonly bool _safeAsync;
#endif
///
/// Asynchronously reads the next JSON token from the source.
///
/// The token to monitor for cancellation requests. The default value is .
/// A that represents the asynchronous read. The
/// property returns true if the next token was read successfully; false if there are no more tokens to read.
/// Derived classes must override this method to get asynchronous behaviour. Otherwise it will
/// execute synchronously, returning an already-completed task.
public override Task ReadAsync(CancellationToken cancellationToken = default)
{
return _safeAsync ? DoReadAsync(cancellationToken) : base.ReadAsync(cancellationToken);
}
internal Task DoReadAsync(CancellationToken cancellationToken)
{
EnsureBuffer();
while (true)
{
switch (_currentState)
{
case State.Start:
case State.Property:
case State.Array:
case State.ArrayStart:
case State.Constructor:
case State.ConstructorStart:
return ParseValueAsync(cancellationToken);
case State.Object:
case State.ObjectStart:
return ParseObjectAsync(cancellationToken);
case State.PostValue:
Task task = ParsePostValueAsync(false, cancellationToken);
if (task.IsCompletedSuccessfully())
{
if (task.Result)
{
return AsyncUtils.True;
}
}
else
{
return DoReadAsync(task, cancellationToken);
}
break;
case State.Finished:
return ReadFromFinishedAsync(cancellationToken);
default:
throw JsonReaderException.Create(this, "Unexpected state: {0}.".FormatWith(CultureInfo.InvariantCulture, CurrentState));
}
}
}
private async Task DoReadAsync(Task task, CancellationToken cancellationToken)
{
bool result = await task.ConfigureAwait(false);
if (result)
{
return true;
}
return await DoReadAsync(cancellationToken).ConfigureAwait(false);
}
private async Task ParsePostValueAsync(bool ignoreComments, CancellationToken cancellationToken)
{
MiscellaneousUtils.Assert(_chars != null);
while (true)
{
char currentChar = _chars[_charPos];
switch (currentChar)
{
case '\0':
if (_charsUsed == _charPos)
{
if (await ReadDataAsync(false, cancellationToken).ConfigureAwait(false) == 0)
{
_currentState = State.Finished;
return false;
}
}
else
{
_charPos++;
}
break;
case '}':
_charPos++;
SetToken(JsonToken.EndObject);
return true;
case ']':
_charPos++;
SetToken(JsonToken.EndArray);
return true;
case ')':
_charPos++;
SetToken(JsonToken.EndConstructor);
return true;
case '/':
await ParseCommentAsync(!ignoreComments, cancellationToken).ConfigureAwait(false);
if (!ignoreComments)
{
return true;
}
break;
case ',':
_charPos++;
// finished parsing
SetStateBasedOnCurrent();
return false;
case ' ':
case StringUtils.Tab:
// eat
_charPos++;
break;
case StringUtils.CarriageReturn:
await ProcessCarriageReturnAsync(false, cancellationToken).ConfigureAwait(false);
break;
case StringUtils.LineFeed:
ProcessLineFeed();
break;
default:
if (char.IsWhiteSpace(currentChar))
{
// eat
_charPos++;
}
else
{
// handle multiple content without comma delimiter
if (SupportMultipleContent && Depth == 0)
{
SetStateBasedOnCurrent();
return false;
}
throw JsonReaderException.Create(this, "After parsing a value an unexpected character was encountered: {0}.".FormatWith(CultureInfo.InvariantCulture, currentChar));
}
break;
}
}
}
private async Task ReadFromFinishedAsync(CancellationToken cancellationToken)
{
MiscellaneousUtils.Assert(_chars != null);
if (await EnsureCharsAsync(0, false, cancellationToken).ConfigureAwait(false))
{
await EatWhitespaceAsync(cancellationToken).ConfigureAwait(false);
if (_isEndOfFile)
{
SetToken(JsonToken.None);
return false;
}
if (_chars[_charPos] == '/')
{
await ParseCommentAsync(true, cancellationToken).ConfigureAwait(false);
return true;
}
throw JsonReaderException.Create(this, "Additional text encountered after finished reading JSON content: {0}.".FormatWith(CultureInfo.InvariantCulture, _chars[_charPos]));
}
SetToken(JsonToken.None);
return false;
}
private Task ReadDataAsync(bool append, CancellationToken cancellationToken)
{
return ReadDataAsync(append, 0, cancellationToken);
}
private async Task ReadDataAsync(bool append, int charsRequired, CancellationToken cancellationToken)
{
MiscellaneousUtils.Assert(_chars != null);
if (_isEndOfFile)
{
return 0;
}
PrepareBufferForReadData(append, charsRequired);
int charsRead = await _reader.ReadAsync(_chars, _charsUsed, _chars.Length - _charsUsed - 1, cancellationToken).ConfigureAwait(false);
_charsUsed += charsRead;
if (charsRead == 0)
{
_isEndOfFile = true;
}
_chars[_charsUsed] = '\0';
return charsRead;
}
private async Task ParseValueAsync(CancellationToken cancellationToken)
{
MiscellaneousUtils.Assert(_chars != null);
while (true)
{
char currentChar = _chars[_charPos];
switch (currentChar)
{
case '\0':
if (_charsUsed == _charPos)
{
if (await ReadDataAsync(false, cancellationToken).ConfigureAwait(false) == 0)
{
return false;
}
}
else
{
_charPos++;
}
break;
case '"':
case '\'':
await ParseStringAsync(currentChar, ReadType.Read, cancellationToken).ConfigureAwait(false);
return true;
case 't':
await ParseTrueAsync(cancellationToken).ConfigureAwait(false);
return true;
case 'f':
await ParseFalseAsync(cancellationToken).ConfigureAwait(false);
return true;
case 'n':
if (await EnsureCharsAsync(1, true, cancellationToken).ConfigureAwait(false))
{
switch (_chars[_charPos + 1])
{
case 'u':
await ParseNullAsync(cancellationToken).ConfigureAwait(false);
break;
case 'e':
await ParseConstructorAsync(cancellationToken).ConfigureAwait(false);
break;
default:
throw CreateUnexpectedCharacterException(_chars[_charPos]);
}
}
else
{
_charPos++;
throw CreateUnexpectedEndException();
}
return true;
case 'N':
await ParseNumberNaNAsync(ReadType.Read, cancellationToken).ConfigureAwait(false);
return true;
case 'I':
await ParseNumberPositiveInfinityAsync(ReadType.Read, cancellationToken).ConfigureAwait(false);
return true;
case '-':
if (await EnsureCharsAsync(1, true, cancellationToken).ConfigureAwait(false) && _chars[_charPos + 1] == 'I')
{
await ParseNumberNegativeInfinityAsync(ReadType.Read, cancellationToken).ConfigureAwait(false);
}
else
{
await ParseNumberAsync(ReadType.Read, cancellationToken).ConfigureAwait(false);
}
return true;
case '/':
await ParseCommentAsync(true, cancellationToken).ConfigureAwait(false);
return true;
case 'u':
await ParseUndefinedAsync(cancellationToken).ConfigureAwait(false);
return true;
case '{':
_charPos++;
SetToken(JsonToken.StartObject);
return true;
case '[':
_charPos++;
SetToken(JsonToken.StartArray);
return true;
case ']':
_charPos++;
SetToken(JsonToken.EndArray);
return true;
case ',':
// don't increment position, the next call to read will handle comma
// this is done to handle multiple empty comma values
SetToken(JsonToken.Undefined);
return true;
case ')':
_charPos++;
SetToken(JsonToken.EndConstructor);
return true;
case StringUtils.CarriageReturn:
await ProcessCarriageReturnAsync(false, cancellationToken).ConfigureAwait(false);
break;
case StringUtils.LineFeed:
ProcessLineFeed();
break;
case ' ':
case StringUtils.Tab:
// eat
_charPos++;
break;
default:
if (char.IsWhiteSpace(currentChar))
{
// eat
_charPos++;
break;
}
if (char.IsNumber(currentChar) || currentChar == '-' || currentChar == '.')
{
await ParseNumberAsync(ReadType.Read, cancellationToken).ConfigureAwait(false);
return true;
}
throw CreateUnexpectedCharacterException(currentChar);
}
}
}
private async Task ReadStringIntoBufferAsync(char quote, CancellationToken cancellationToken)
{
MiscellaneousUtils.Assert(_chars != null);
int charPos = _charPos;
int initialPosition = _charPos;
int lastWritePosition = _charPos;
_stringBuffer.Position = 0;
while (true)
{
switch (_chars[charPos++])
{
case '\0':
if (_charsUsed == charPos - 1)
{
charPos--;
if (await ReadDataAsync(true, cancellationToken).ConfigureAwait(false) == 0)
{
_charPos = charPos;
throw JsonReaderException.Create(this, "Unterminated string. Expected delimiter: {0}.".FormatWith(CultureInfo.InvariantCulture, quote));
}
}
break;
case '\\':
_charPos = charPos;
if (!await EnsureCharsAsync(0, true, cancellationToken).ConfigureAwait(false))
{
throw JsonReaderException.Create(this, "Unterminated string. Expected delimiter: {0}.".FormatWith(CultureInfo.InvariantCulture, quote));
}
// start of escape sequence
int escapeStartPos = charPos - 1;
char currentChar = _chars[charPos];
charPos++;
char writeChar;
switch (currentChar)
{
case 'b':
writeChar = '\b';
break;
case 't':
writeChar = '\t';
break;
case 'n':
writeChar = '\n';
break;
case 'f':
writeChar = '\f';
break;
case 'r':
writeChar = '\r';
break;
case '\\':
writeChar = '\\';
break;
case '"':
case '\'':
case '/':
writeChar = currentChar;
break;
case 'u':
_charPos = charPos;
writeChar = await ParseUnicodeAsync(cancellationToken).ConfigureAwait(false);
if (StringUtils.IsLowSurrogate(writeChar))
{
// low surrogate with no preceding high surrogate; this char is replaced
writeChar = UnicodeReplacementChar;
}
else if (StringUtils.IsHighSurrogate(writeChar))
{
bool anotherHighSurrogate;
// loop for handling situations where there are multiple consecutive high surrogates
do
{
anotherHighSurrogate = false;
// potential start of a surrogate pair
if (await EnsureCharsAsync(2, true, cancellationToken).ConfigureAwait(false) && _chars[_charPos] == '\\' && _chars[_charPos + 1] == 'u')
{
char highSurrogate = writeChar;
_charPos += 2;
writeChar = await ParseUnicodeAsync(cancellationToken).ConfigureAwait(false);
if (StringUtils.IsLowSurrogate(writeChar))
{
// a valid surrogate pair!
}
else if (StringUtils.IsHighSurrogate(writeChar))
{
// another high surrogate; replace current and start check over
highSurrogate = UnicodeReplacementChar;
anotherHighSurrogate = true;
}
else
{
// high surrogate not followed by low surrogate; original char is replaced
highSurrogate = UnicodeReplacementChar;
}
EnsureBufferNotEmpty();
WriteCharToBuffer(highSurrogate, lastWritePosition, escapeStartPos);
lastWritePosition = _charPos;
}
else
{
// there are not enough remaining chars for the low surrogate or is not follow by unicode sequence
// replace high surrogate and continue on as usual
writeChar = UnicodeReplacementChar;
}
} while (anotherHighSurrogate);
}
charPos = _charPos;
break;
default:
_charPos = charPos;
throw JsonReaderException.Create(this, "Bad JSON escape sequence: {0}.".FormatWith(CultureInfo.InvariantCulture, @"\" + currentChar));
}
EnsureBufferNotEmpty();
WriteCharToBuffer(writeChar, lastWritePosition, escapeStartPos);
lastWritePosition = charPos;
break;
case StringUtils.CarriageReturn:
_charPos = charPos - 1;
await ProcessCarriageReturnAsync(true, cancellationToken).ConfigureAwait(false);
charPos = _charPos;
break;
case StringUtils.LineFeed:
_charPos = charPos - 1;
ProcessLineFeed();
charPos = _charPos;
break;
case '"':
case '\'':
if (_chars[charPos - 1] == quote)
{
FinishReadStringIntoBuffer(charPos - 1, initialPosition, lastWritePosition);
return;
}
break;
}
}
}
private Task ProcessCarriageReturnAsync(bool append, CancellationToken cancellationToken)
{
_charPos++;
Task task = EnsureCharsAsync(1, append, cancellationToken);
if (task.IsCompletedSuccessfully())
{
SetNewLine(task.Result);
return AsyncUtils.CompletedTask;
}
return ProcessCarriageReturnAsync(task);
}
private async Task ProcessCarriageReturnAsync(Task task)
{
SetNewLine(await task.ConfigureAwait(false));
}
private async Task ParseUnicodeAsync(CancellationToken cancellationToken)
{
return ConvertUnicode(await EnsureCharsAsync(4, true, cancellationToken).ConfigureAwait(false));
}
private Task EnsureCharsAsync(int relativePosition, bool append, CancellationToken cancellationToken)
{
if (_charPos + relativePosition < _charsUsed)
{
return AsyncUtils.True;
}
if (_isEndOfFile)
{
return AsyncUtils.False;
}
return ReadCharsAsync(relativePosition, append, cancellationToken);
}
private async Task ReadCharsAsync(int relativePosition, bool append, CancellationToken cancellationToken)
{
int charsRequired = _charPos + relativePosition - _charsUsed + 1;
// it is possible that the TextReader doesn't return all data at once
// repeat read until the required text is returned or the reader is out of content
do
{
int charsRead = await ReadDataAsync(append, charsRequired, cancellationToken).ConfigureAwait(false);
// no more content
if (charsRead == 0)
{
return false;
}
charsRequired -= charsRead;
} while (charsRequired > 0);
return true;
}
private async Task ParseObjectAsync(CancellationToken cancellationToken)
{
MiscellaneousUtils.Assert(_chars != null);
while (true)
{
char currentChar = _chars[_charPos];
switch (currentChar)
{
case '\0':
if (_charsUsed == _charPos)
{
if (await ReadDataAsync(false, cancellationToken).ConfigureAwait(false) == 0)
{
return false;
}
}
else
{
_charPos++;
}
break;
case '}':
SetToken(JsonToken.EndObject);
_charPos++;
return true;
case '/':
await ParseCommentAsync(true, cancellationToken).ConfigureAwait(false);
return true;
case StringUtils.CarriageReturn:
await ProcessCarriageReturnAsync(false, cancellationToken).ConfigureAwait(false);
break;
case StringUtils.LineFeed:
ProcessLineFeed();
break;
case ' ':
case StringUtils.Tab:
// eat
_charPos++;
break;
default:
if (char.IsWhiteSpace(currentChar))
{
// eat
_charPos++;
}
else
{
return await ParsePropertyAsync(cancellationToken).ConfigureAwait(false);
}
break;
}
}
}
private async Task ParseCommentAsync(bool setToken, CancellationToken cancellationToken)
{
MiscellaneousUtils.Assert(_chars != null);
// should have already parsed / character before reaching this method
_charPos++;
if (!await EnsureCharsAsync(1, false, cancellationToken).ConfigureAwait(false))
{
throw JsonReaderException.Create(this, "Unexpected end while parsing comment.");
}
bool singlelineComment;
if (_chars[_charPos] == '*')
{
singlelineComment = false;
}
else if (_chars[_charPos] == '/')
{
singlelineComment = true;
}
else
{
throw JsonReaderException.Create(this, "Error parsing comment. Expected: *, got {0}.".FormatWith(CultureInfo.InvariantCulture, _chars[_charPos]));
}
_charPos++;
int initialPosition = _charPos;
while (true)
{
switch (_chars[_charPos])
{
case '\0':
if (_charsUsed == _charPos)
{
if (await ReadDataAsync(true, cancellationToken).ConfigureAwait(false) == 0)
{
if (!singlelineComment)
{
throw JsonReaderException.Create(this, "Unexpected end while parsing comment.");
}
EndComment(setToken, initialPosition, _charPos);
return;
}
}
else
{
_charPos++;
}
break;
case '*':
_charPos++;
if (!singlelineComment)
{
if (await EnsureCharsAsync(0, true, cancellationToken).ConfigureAwait(false))
{
if (_chars[_charPos] == '/')
{
EndComment(setToken, initialPosition, _charPos - 1);
_charPos++;
return;
}
}
}
break;
case StringUtils.CarriageReturn:
if (singlelineComment)
{
EndComment(setToken, initialPosition, _charPos);
return;
}
await ProcessCarriageReturnAsync(true, cancellationToken).ConfigureAwait(false);
break;
case StringUtils.LineFeed:
if (singlelineComment)
{
EndComment(setToken, initialPosition, _charPos);
return;
}
ProcessLineFeed();
break;
default:
_charPos++;
break;
}
}
}
private async Task EatWhitespaceAsync(CancellationToken cancellationToken)
{
MiscellaneousUtils.Assert(_chars != null);
while (true)
{
char currentChar = _chars[_charPos];
switch (currentChar)
{
case '\0':
if (_charsUsed == _charPos)
{
if (await ReadDataAsync(false, cancellationToken).ConfigureAwait(false) == 0)
{
return;
}
}
else
{
_charPos++;
}
break;
case StringUtils.CarriageReturn:
await ProcessCarriageReturnAsync(false, cancellationToken).ConfigureAwait(false);
break;
case StringUtils.LineFeed:
ProcessLineFeed();
break;
default:
if (currentChar == ' ' || char.IsWhiteSpace(currentChar))
{
_charPos++;
}
else
{
return;
}
break;
}
}
}
private async Task ParseStringAsync(char quote, ReadType readType, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
_charPos++;
ShiftBufferIfNeeded();
await ReadStringIntoBufferAsync(quote, cancellationToken).ConfigureAwait(false);
ParseReadString(quote, readType);
}
private async Task MatchValueAsync(string value, CancellationToken cancellationToken)
{
return MatchValue(await EnsureCharsAsync(value.Length - 1, true, cancellationToken).ConfigureAwait(false), value);
}
private async Task MatchValueWithTrailingSeparatorAsync(string value, CancellationToken cancellationToken)
{
MiscellaneousUtils.Assert(_chars != null);
// will match value and then move to the next character, checking that it is a separator character
if (!await MatchValueAsync(value, cancellationToken).ConfigureAwait(false))
{
return false;
}
if (!await EnsureCharsAsync(0, false, cancellationToken).ConfigureAwait(false))
{
return true;
}
return IsSeparator(_chars[_charPos]) || _chars[_charPos] == '\0';
}
private async Task MatchAndSetAsync(string value, JsonToken newToken, object? tokenValue, CancellationToken cancellationToken)
{
if (await MatchValueWithTrailingSeparatorAsync(value, cancellationToken).ConfigureAwait(false))
{
SetToken(newToken, tokenValue);
}
else
{
throw JsonReaderException.Create(this, "Error parsing " + newToken.ToString().ToLowerInvariant() + " value.");
}
}
private Task ParseTrueAsync(CancellationToken cancellationToken)
{
return MatchAndSetAsync(JsonConvert.True, JsonToken.Boolean, true, cancellationToken);
}
private Task ParseFalseAsync(CancellationToken cancellationToken)
{
return MatchAndSetAsync(JsonConvert.False, JsonToken.Boolean, false, cancellationToken);
}
private Task ParseNullAsync(CancellationToken cancellationToken)
{
return MatchAndSetAsync(JsonConvert.Null, JsonToken.Null, null, cancellationToken);
}
private async Task ParseConstructorAsync(CancellationToken cancellationToken)
{
MiscellaneousUtils.Assert(_chars != null);
if (await MatchValueWithTrailingSeparatorAsync("new", cancellationToken).ConfigureAwait(false))
{
await EatWhitespaceAsync(cancellationToken).ConfigureAwait(false);
int initialPosition = _charPos;
int endPosition;
while (true)
{
char currentChar = _chars[_charPos];
if (currentChar == '\0')
{
if (_charsUsed == _charPos)
{
if (await ReadDataAsync(true, cancellationToken).ConfigureAwait(false) == 0)
{
throw JsonReaderException.Create(this, "Unexpected end while parsing constructor.");
}
}
else
{
endPosition = _charPos;
_charPos++;
break;
}
}
else if (char.IsLetterOrDigit(currentChar))
{
_charPos++;
}
else if (currentChar == StringUtils.CarriageReturn)
{
endPosition = _charPos;
await ProcessCarriageReturnAsync(true, cancellationToken).ConfigureAwait(false);
break;
}
else if (currentChar == StringUtils.LineFeed)
{
endPosition = _charPos;
ProcessLineFeed();
break;
}
else if (char.IsWhiteSpace(currentChar))
{
endPosition = _charPos;
_charPos++;
break;
}
else if (currentChar == '(')
{
endPosition = _charPos;
break;
}
else
{
throw JsonReaderException.Create(this, "Unexpected character while parsing constructor: {0}.".FormatWith(CultureInfo.InvariantCulture, currentChar));
}
}
_stringReference = new StringReference(_chars, initialPosition, endPosition - initialPosition);
string constructorName = _stringReference.ToString();
await EatWhitespaceAsync(cancellationToken).ConfigureAwait(false);
if (_chars[_charPos] != '(')
{
throw JsonReaderException.Create(this, "Unexpected character while parsing constructor: {0}.".FormatWith(CultureInfo.InvariantCulture, _chars[_charPos]));
}
_charPos++;
ClearRecentString();
SetToken(JsonToken.StartConstructor, constructorName);
}
else
{
throw JsonReaderException.Create(this, "Unexpected content while parsing JSON.");
}
}
private async Task
