1645 references to JsonSerializer
aspire (87)
Agents\ClaudeCode\ClaudeCodeAgentEnvironmentScanner.cs (2)
293var jsonContent = JsonSerializer.Serialize(config, JsonSourceGenerationContext.Default.JsonObject); 334var jsonContent = JsonSerializer.Serialize(config, JsonSourceGenerationContext.Default.JsonObject);
Agents\CopilotCli\CopilotCliAgentEnvironmentScanner.cs (2)
261var jsonContent = JsonSerializer.Serialize(config, JsonSourceGenerationContext.Default.JsonObject); 312var jsonContent = JsonSerializer.Serialize(config, JsonSourceGenerationContext.Default.JsonObject);
Agents\DeprecatedMcpCommandScanner.cs (1)
213var jsonContent = JsonSerializer.Serialize(config, JsonSourceGenerationContext.Default.JsonObject);
Agents\OpenCode\OpenCodeAgentEnvironmentScanner.cs (2)
242var jsonOutput = JsonSerializer.Serialize(config, JsonSourceGenerationContext.Default.JsonObject); 290var jsonOutput = JsonSerializer.Serialize(config, JsonSourceGenerationContext.Default.JsonObject);
Agents\VsCode\VsCodeAgentEnvironmentScanner.cs (2)
327var jsonContent = JsonSerializer.Serialize(config, JsonSourceGenerationContext.Default.JsonObject); 375var jsonContent = JsonSerializer.Serialize(config, JsonSourceGenerationContext.Default.JsonObject);
AppHostListInfoSerializerContext.AppHostListInfo.g.cs (1)
131global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Aspire.Cli.Mcp.Tools.AppHostListInfo)value).CliPid, NullableInt32);
BackchannelJsonSerializerContext.AppHostInformation.g.cs (2)
153global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Aspire.Cli.Backchannel.AppHostInformation)value).CliProcessId, NullableInt32); 155global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Aspire.Cli.Backchannel.AppHostInformation)value).StartedAt, NullableDateTimeOffset);
BackchannelJsonSerializerContext.BackchannelLogEntry.g.cs (1)
178global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Aspire.Cli.Backchannel.BackchannelLogEntry)value).LogLevel, LogLevel);
BackchannelJsonSerializerContext.CallMcpToolRequest.g.cs (1)
135global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Aspire.Cli.Backchannel.CallMcpToolRequest)value).Arguments, NullableJsonElement);
BackchannelJsonSerializerContext.CommandOutput.g.cs (2)
172global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Aspire.Cli.Backchannel.CommandOutput)value).LineNumber, NullableInt32); 175global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Aspire.Cli.Backchannel.CommandOutput)value).ExitCode, NullableInt32);
BackchannelJsonSerializerContext.DictionaryStringJsonElement.g.cs (1)
58global::System.Text.Json.JsonSerializer.Serialize(writer, entry.Value, JsonElement);
BackchannelJsonSerializerContext.GetAppHostInfoResponse.g.cs (2)
179global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Aspire.Cli.Backchannel.GetAppHostInfoResponse)value).CliProcessId, NullableInt32); 181global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Aspire.Cli.Backchannel.GetAppHostInfoResponse)value).StartedAt, NullableDateTimeOffset);
BackchannelJsonSerializerContext.PublishingActivityData.g.cs (1)
348global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Aspire.Cli.Backchannel.PublishingActivityData)value).Timestamp, NullableDateTimeOffset);
BackchannelJsonSerializerContext.RequestId.g.cs (1)
141global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::StreamJsonRpc.RequestId)value).Number, NullableInt64);
BackchannelJsonSerializerContext.ResourceSnapshot.g.cs (4)
471global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Aspire.Cli.Backchannel.ResourceSnapshot)value).ExitCode, NullableInt32); 473global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Aspire.Cli.Backchannel.ResourceSnapshot)value).CreatedAt, NullableDateTimeOffset); 475global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Aspire.Cli.Backchannel.ResourceSnapshot)value).StartedAt, NullableDateTimeOffset); 477global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Aspire.Cli.Backchannel.ResourceSnapshot)value).StoppedAt, NullableDateTimeOffset);
BackchannelJsonSerializerContext.StopAppHostRequest.g.cs (1)
87global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Aspire.Cli.Backchannel.StopAppHostRequest)value).ExitCode, NullableInt32);
BackchannelJsonSerializerContext.Tool.g.cs (3)
252global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::ModelContextProtocol.Protocol.Tool)value).InputSchema, JsonElement); 254global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::ModelContextProtocol.Protocol.Tool)value).OutputSchema, NullableJsonElement); 260global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::ModelContextProtocol.Protocol.Tool)value).Meta, JsonObject);
BackchannelJsonSerializerContext.ToolAnnotations.g.cs (4)
168global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::ModelContextProtocol.Protocol.ToolAnnotations)value).DestructiveHint, NullableBoolean); 170global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::ModelContextProtocol.Protocol.ToolAnnotations)value).IdempotentHint, NullableBoolean); 172global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::ModelContextProtocol.Protocol.ToolAnnotations)value).OpenWorldHint, NullableBoolean); 174global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::ModelContextProtocol.Protocol.ToolAnnotations)value).ReadOnlyHint, NullableBoolean);
Certificates\BundleCertificateToolRunner.cs (1)
102var certificates = JsonSerializer.Deserialize(jsonOutput, Aspire.Cli.JsonSourceGenerationContext.Default.ListDevCertInfo);
Certificates\SdkCertificateToolRunner.cs (1)
77var certificates = JsonSerializer.Deserialize(jsonOutput, Aspire.Cli.JsonSourceGenerationContext.Default.ListDevCertInfo);
Commands\AgentMcpCommand.cs (1)
216_logger.LogDebug("Invoking tool {Name} with arguments {Arguments}", toolName, JsonSerializer.Serialize(args, BackchannelJsonSerializerContext.Default.DictionaryStringJsonElement));
Commands\ConfigCommand.cs (1)
413var json = System.Text.Json.JsonSerializer.Serialize(info, JsonSourceGenerationContext.Default.ConfigInfo);
Commands\DocsGetCommand.cs (1)
83var json = JsonSerializer.Serialize(doc, JsonSourceGenerationContext.RelaxedEscaping.DocsContent);
Commands\DocsListCommand.cs (1)
70var json = JsonSerializer.Serialize(docs.ToArray(), JsonSourceGenerationContext.RelaxedEscaping.DocsListItemArray);
Commands\DocsSearchCommand.cs (1)
84var json = JsonSerializer.Serialize(response.Results.ToArray(), JsonSourceGenerationContext.RelaxedEscaping.SearchResultArray);
Commands\DoctorCommand.cs (1)
84var json = System.Text.Json.JsonSerializer.Serialize(response, JsonSourceGenerationContext.RelaxedEscaping.DoctorCheckResponse);
Commands\ExtensionInternalCommand.cs (1)
46var json = JsonSerializer.Serialize(new AppHostProjectSearchResultPoco
Commands\LogsCommand.cs (2)
222var json = JsonSerializer.Serialize(logsOutput, LogsCommandJsonContext.Snapshot.LogsOutput); 329var output = JsonSerializer.Serialize(logLineJson, LogsCommandJsonContext.Ndjson.LogLineJson);
Commands\PsCommand.cs (1)
120var json = JsonSerializer.Serialize(appHostInfos, PsCommandJsonContext.RelaxedEscaping.ListAppHostDisplayInfo);
Commands\ResourcesCommand.cs (2)
178var json = JsonSerializer.Serialize(output, ResourcesCommandJsonContext.RelaxedEscaping.ResourcesOutput); 215var json = JsonSerializer.Serialize(resourceJson, ResourcesCommandJsonContext.Ndjson.ResourceJson);
Commands\RunCommand.cs (1)
894var json = JsonSerializer.Serialize(result, RunCommandJsonContext.RelaxedEscaping.DetachOutputInfo);
Commands\Sdk\SdkDumpCommand.cs (1)
251return JsonSerializer.Serialize(capabilities, CapabilitiesJsonContext.Default.CapabilitiesInfo);
Commands\TelemetryLogsCommand.cs (2)
215var response = JsonSerializer.Deserialize(json, OtlpCliJsonSerializerContext.Default.TelemetryApiResponse); 229var request = JsonSerializer.Deserialize(json, OtlpCliJsonSerializerContext.Default.OtlpExportLogsServiceRequestJson);
Commands\TelemetrySpansCommand.cs (2)
217var response = JsonSerializer.Deserialize(json, OtlpCliJsonSerializerContext.Default.TelemetryApiResponse); 231var request = JsonSerializer.Deserialize(json, OtlpCliJsonSerializerContext.Default.OtlpExportTraceServiceRequestJson);
Commands\TelemetryTracesCommand.cs (2)
221var response = JsonSerializer.Deserialize(json, OtlpCliJsonSerializerContext.Default.TelemetryApiResponse); 284var response = JsonSerializer.Deserialize(json, OtlpCliJsonSerializerContext.Default.TelemetryApiResponse);
Configuration\AspireJsonConfiguration.cs (2)
112return JsonSerializer.Deserialize(json, JsonSourceGenerationContext.Default.AspireJsonConfiguration); 139var json = JsonSerializer.Serialize(this, JsonSourceGenerationContext.Default.AspireJsonConfiguration);
Configuration\ConfigurationService.cs (2)
44var jsonContent = JsonSerializer.Serialize(settings, JsonSourceGenerationContext.Default.JsonObject); 80var jsonContent = JsonSerializer.Serialize(settings, JsonSourceGenerationContext.Default.JsonObject);
DotNet\DotNetCliRunner.cs (1)
507var certificates = JsonSerializer.Deserialize(jsonOutput, JsonSourceGenerationContext.Default.ListDevCertInfo);
JsonSourceGenerationContext.DictionaryStringJsonElement.g.cs (1)
58global::System.Text.Json.JsonSerializer.Serialize(writer, entry.Value, JsonElement);
JsonSourceGenerationContext.ListEnvironmentCheckResult.g.cs (1)
57global::System.Text.Json.JsonSerializer.Serialize(writer, value[i], EnvironmentCheckResult);
ListResourcesToolJsonContext.ResourceJson.g.cs (4)
500global::System.Text.Json.JsonSerializer.Serialize(writer, __value_CreationTimestamp, NullableDateTimeOffset); 506global::System.Text.Json.JsonSerializer.Serialize(writer, __value_StartTimestamp, NullableDateTimeOffset); 512global::System.Text.Json.JsonSerializer.Serialize(writer, __value_StopTimestamp, NullableDateTimeOffset); 523global::System.Text.Json.JsonSerializer.Serialize(writer, __value_ExitCode, NullableInt32);
Mcp\Docs\DocsCache.cs (2)
331return await JsonSerializer.DeserializeAsync(stream, JsonSourceGenerationContext.Default.LlmsDocumentArray, cancellationToken).ConfigureAwait(false); 367await JsonSerializer.SerializeAsync(stream, documents, JsonSourceGenerationContext.Default.LlmsDocumentArray, cancellationToken).ConfigureAwait(false);
Mcp\Tools\DoctorTool.cs (1)
54var jsonContent = JsonSerializer.Serialize(response, JsonSourceGenerationContext.Default.DoctorCheckResponse);
Mcp\Tools\ListAppHostsTool.cs (2)
69var inScopeJson = JsonSerializer.Serialize(inScopeAppHosts, AppHostListInfoSerializerContext.Default.ListAppHostListInfo); 76var outOfScopeJson = JsonSerializer.Serialize(outOfScopeAppHosts, AppHostListInfoSerializerContext.Default.ListAppHostListInfo);
Mcp\Tools\ListIntegrationsTool.cs (1)
128var jsonContent = JsonSerializer.Serialize(response, JsonSourceGenerationContext.Default.ListIntegrationsResponse);
Mcp\Tools\ListResourcesTool.cs (1)
89var resourceGraphData = JsonSerializer.Serialize(resources.ToArray(), ListResourcesToolJsonContext.RelaxedEscaping.ResourceJsonArray);
NuGet\BundleNuGetPackageCache.cs (1)
194var result = JsonSerializer.Deserialize(output, BundleSearchJsonContext.Default.BundleSearchResult);
OtlpCliJsonSerializerContext.OtlpAnyValueJsonArray.g.cs (1)
57global::System.Text.Json.JsonSerializer.Serialize(writer, value[i], OtlpAnyValueJson);
OtlpCliJsonSerializerContext.OtlpKeyValueJson.g.cs (1)
115global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Value, OtlpAnyValueJson);
OtlpCliJsonSerializerContext.OtlpLogRecordJsonArray.g.cs (1)
57global::System.Text.Json.JsonSerializer.Serialize(writer, value[i], OtlpLogRecordJson);
OtlpCliJsonSerializerContext.OtlpSpanEventJsonArray.g.cs (1)
57global::System.Text.Json.JsonSerializer.Serialize(writer, value[i], OtlpSpanEventJson);
OtlpCliJsonSerializerContext.OtlpSpanJsonArray.g.cs (1)
57global::System.Text.Json.JsonSerializer.Serialize(writer, value[i], OtlpSpanJson);
OtlpCliJsonSerializerContext.OtlpSpanLinkJson.g.cs (1)
216global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Flags, NullableUInt32);
OtlpCliJsonSerializerContext.OtlpSpanStatusJson.g.cs (1)
115global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Code, NullableInt32);
PsCommandJsonContext.AppHostDisplayInfo.g.cs (1)
151global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Aspire.Cli.Commands.AppHostDisplayInfo)value).CliPid, NullableInt32);
ResourcesCommandJsonContext.ResourceJson.g.cs (4)
500global::System.Text.Json.JsonSerializer.Serialize(writer, __value_CreationTimestamp, NullableDateTimeOffset); 506global::System.Text.Json.JsonSerializer.Serialize(writer, __value_StartTimestamp, NullableDateTimeOffset); 512global::System.Text.Json.JsonSerializer.Serialize(writer, __value_StopTimestamp, NullableDateTimeOffset); 523global::System.Text.Json.JsonSerializer.Serialize(writer, __value_ExitCode, NullableInt32);
Utils\EnvironmentChecker\ContainerRuntimeCheck.cs (1)
514var json = JsonSerializer.Deserialize(output, JsonSourceGenerationContext.Default.ContainerVersionJson);
Aspire.Cli.Tests (45)
Backchannel\BackchannelJsonSerializerContextTests.cs (4)
34var json = JsonSerializer.Serialize(servers, options); 35var roundTripped = JsonSerializer.Deserialize<Aspire.Cli.Backchannel.ResourceSnapshotMcpServer[]>(json, options); 55var json = JsonSerializer.Serialize(payload, options); 56var roundTripped = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(json, options);
Commands\ExtensionInternalCommandTests.cs (2)
85searchResult = JsonSerializer.Deserialize(allOutput, BackchannelJsonSerializerContext.Default.AppHostProjectSearchResultPoco); 128searchResult = JsonSerializer.Deserialize(allOutput, BackchannelJsonSerializerContext.Default.AppHostProjectSearchResultPoco);
Commands\LogsCommandTests.cs (14)
42var json = JsonSerializer.Serialize(logLine, LogsCommandJsonContext.Ndjson.LogLineJson); 50var deserialized = JsonSerializer.Deserialize(json, LogsCommandJsonContext.Ndjson.LogLineJson); 69var json = JsonSerializer.Serialize(logLine, LogsCommandJsonContext.Default.LogLineJson); 87var json = JsonSerializer.Serialize(logLine, LogsCommandJsonContext.Ndjson.LogLineJson); 90var deserialized = JsonSerializer.Deserialize(json, LogsCommandJsonContext.Ndjson.LogLineJson); 106var json = JsonSerializer.Serialize(logLine, LogsCommandJsonContext.Ndjson.LogLineJson); 107var deserialized = JsonSerializer.Deserialize(json, LogsCommandJsonContext.Ndjson.LogLineJson); 282.Select(l => JsonSerializer.Serialize(l, LogsCommandJsonContext.Ndjson.LogLineJson)) 293var deserialized = JsonSerializer.Deserialize(line, LogsCommandJsonContext.Ndjson.LogLineJson); 300.Select(line => JsonSerializer.Deserialize(line, LogsCommandJsonContext.Ndjson.LogLineJson)) 324var json = JsonSerializer.Serialize(logsOutput, LogsCommandJsonContext.Snapshot.LogsOutput); 332var deserialized = JsonSerializer.Deserialize(json, LogsCommandJsonContext.Snapshot.LogsOutput); 351var json = JsonSerializer.Serialize(logLine, LogsCommandJsonContext.Ndjson.LogLineJson); 363var deserialized = JsonSerializer.Deserialize(json, LogsCommandJsonContext.Ndjson.LogLineJson);
Commands\ResourcesCommandTests.cs (5)
169.Select(r => System.Text.Json.JsonSerializer.Serialize(r, ResourcesCommandJsonContext.Ndjson.ResourceJson)) 180var deserialized = System.Text.Json.JsonSerializer.Deserialize(line, ResourcesCommandJsonContext.Ndjson.ResourceJson); 187.Select(line => System.Text.Json.JsonSerializer.Deserialize(line, ResourcesCommandJsonContext.Ndjson.ResourceJson)) 210var json = System.Text.Json.JsonSerializer.Serialize(resourcesOutput, ResourcesCommandJsonContext.RelaxedEscaping.ResourcesOutput); 218var deserialized = System.Text.Json.JsonSerializer.Deserialize(json, ResourcesCommandJsonContext.RelaxedEscaping.ResourcesOutput);
Mcp\ListStructuredLogsToolTests.cs (6)
143var apiResponse = JsonSerializer.Serialize(apiResponseObj, OtlpCliJsonSerializerContext.Default.TelemetryApiResponse); 152var resourcesResponse = JsonSerializer.Serialize(resources, OtlpCliJsonSerializerContext.Default.ResourceInfoJsonArray); 249var apiResponse = JsonSerializer.Serialize(apiResponseObj, OtlpCliJsonSerializerContext.Default.TelemetryApiResponse); 255var resourcesResponse = JsonSerializer.Serialize(resources, OtlpCliJsonSerializerContext.Default.ResourceInfoJsonArray); 302var resourcesResponse = JsonSerializer.Serialize(resources, OtlpCliJsonSerializerContext.Default.ResourceInfoJsonArray); 310var emptyLogsJson = JsonSerializer.Serialize(emptyLogsResponse, OtlpCliJsonSerializerContext.Default.TelemetryApiResponse);
Mcp\ListTracesToolTests.cs (8)
115var apiResponse = JsonSerializer.Serialize(apiResponseObj, OtlpCliJsonSerializerContext.Default.TelemetryApiResponse); 124var resourcesResponse = JsonSerializer.Serialize(resources, OtlpCliJsonSerializerContext.Default.ResourceInfoJsonArray); 231var apiResponse = JsonSerializer.Serialize(apiResponseObj, OtlpCliJsonSerializerContext.Default.TelemetryApiResponse); 237var resourcesResponse = JsonSerializer.Serialize(resources, OtlpCliJsonSerializerContext.Default.ResourceInfoJsonArray); 284var resourcesResponse = JsonSerializer.Serialize(resources, OtlpCliJsonSerializerContext.Default.ResourceInfoJsonArray); 292var emptyTracesJson = JsonSerializer.Serialize(emptyTracesResponse, OtlpCliJsonSerializerContext.Default.TelemetryApiResponse); 386var apiResponse = JsonSerializer.Serialize(apiResponseObj, OtlpCliJsonSerializerContext.Default.TelemetryApiResponse); 393var resourcesResponse = JsonSerializer.Serialize(resources, OtlpCliJsonSerializerContext.Default.ResourceInfoJsonArray);
Projects\FallbackProjectParserTests.cs (1)
17return JsonSerializer.Serialize(document.RootElement, s_indentedOptions);
Projects\ProjectLocatorTests.cs (5)
66await JsonSerializer.SerializeAsync(writer, new 100await JsonSerializer.SerializeAsync(writer, new 128await JsonSerializer.SerializeAsync(writer, new 172await JsonSerializer.SerializeAsync(writer, new 311var settings = JsonSerializer.Deserialize<CliSettings>(settingsJson);
Aspire.Confluent.Kafka (1)
MetricsService.cs (1)
26statistics = JsonSerializer.Deserialize(json, StatisticsJsonSerializerContext.Default.Statistics);
Aspire.Dashboard (56)
Api\TelemetryApiService.cs (1)
387yield return JsonSerializer.Serialize(otlpData, OtlpJsonSerializerContext.DefaultOptions);
Components\Dialogs\McpServerDialog.razor.cs (4)
134var installButtonJson = JsonSerializer.Serialize( 145var configFileJson = JsonSerializer.Serialize( 168var installButtonJson = JsonSerializer.Serialize( 178var configFileJson = JsonSerializer.Serialize(
GenAIEventsContext.ToolCallFunction.g.cs (1)
115global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Arguments, JsonNode);
GenAIEventsContext.ToolEvent.g.cs (1)
115global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Content, JsonNode);
GenAIMessagesContext.DictionaryStringJsonElement.g.cs (1)
58global::System.Text.Json.JsonSerializer.Serialize(writer, entry.Value, JsonElement);
GenAIMessagesContext.ListMessagePart.g.cs (1)
57global::System.Text.Json.JsonSerializer.Serialize(writer, value[i], MessagePart);
GenAIMessagesContext.ToolCallRequestPart.g.cs (1)
162global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Arguments, JsonNode);
GenAIMessagesContext.ToolCallResponsePart.g.cs (1)
137global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Response, JsonNode);
McpConfigFileModelContext.McpInputModel.g.cs (1)
174global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Password, NullableBoolean);
McpInstallButtonModelContext.McpInputModel.g.cs (1)
174global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Password, NullableBoolean);
Model\BrowserStorage\LocalBrowserStorage.cs (2)
36return new StorageResult<TValue>(true, JsonSerializer.Deserialize<TValue>(json, s_options)); 48var json = JsonSerializer.Serialize(value, s_options);
Model\GenAI\GenAIMessages.cs (5)
116MessagePart.TextType => JsonSerializer.Deserialize<TextPart>(doc.RootElement.GetRawText(), options), 117MessagePart.ToolCallType => JsonSerializer.Deserialize<ToolCallRequestPart>(doc.RootElement.GetRawText(), options), 118MessagePart.ToolCallResponseType => JsonSerializer.Deserialize<ToolCallResponsePart>(doc.RootElement.GetRawText(), options), 119_ => JsonSerializer.Deserialize<GenericPart>(doc.RootElement.GetRawText(), options), 125JsonSerializer.Serialize(writer, (object)value, value.GetType(), options);
Model\GenAI\GenAIVisualizerDialogViewModel.cs (1)
511return JsonSerializer.Deserialize<TValue>(json, jsonTypeInfo)!;
Model\TelemetryExportService.cs (5)
335return JsonSerializer.Serialize(data, options); 364return JsonSerializer.Serialize(data, OtlpJsonSerializerContext.IndentedOptions); 387return JsonSerializer.Serialize(data, OtlpJsonSerializerContext.IndentedOptions); 698JsonSerializer.Serialize(entryStream, data, OtlpJsonSerializerContext.IndentedOptions); 804return JsonSerializer.Serialize(resourceJson, ResourceJsonSerializerContext.IndentedOptions);
Model\TelemetryImportService.cs (1)
119telemetryData = JsonSerializer.Deserialize<OtlpTelemetryDataJson>(jsonContent, OtlpJsonSerializerContext.DefaultOptions);
Otlp\Http\OtlpHttpEndpointsBuilder.cs (1)
116var json = JsonSerializer.Serialize(status, s_jsonOptions);
Otlp\Http\OtlpJsonConverters.cs (6)
19var jsonObj = JsonSerializer.Deserialize(json, OtlpJsonSerializerContext.Default.OtlpExportTraceServiceRequestJson); 24var jsonObj = JsonSerializer.Deserialize(json, OtlpJsonSerializerContext.Default.OtlpExportLogsServiceRequestJson); 29var jsonObj = JsonSerializer.Deserialize(json, OtlpJsonSerializerContext.Default.OtlpExportMetricsServiceRequestJson); 39return JsonSerializer.Serialize(json, OtlpJsonSerializerContext.Default.OtlpExportTraceServiceResponseJson); 44return JsonSerializer.Serialize(json, OtlpJsonSerializerContext.Default.OtlpExportLogsServiceResponseJson); 49return JsonSerializer.Serialize(json, OtlpJsonSerializerContext.Default.OtlpExportMetricsServiceResponseJson);
OtlpJsonSerializerContext.OtlpAnyValueJsonArray.g.cs (1)
57global::System.Text.Json.JsonSerializer.Serialize(writer, value[i], OtlpAnyValueJson);
OtlpJsonSerializerContext.OtlpExemplarJsonArray.g.cs (1)
57global::System.Text.Json.JsonSerializer.Serialize(writer, value[i], OtlpExemplarJson);
OtlpJsonSerializerContext.OtlpExponentialHistogramDataPointJsonArray.g.cs (1)
57global::System.Text.Json.JsonSerializer.Serialize(writer, value[i], OtlpExponentialHistogramDataPointJson);
OtlpJsonSerializerContext.OtlpExponentialHistogramJson.g.cs (1)
116global::System.Text.Json.JsonSerializer.Serialize(writer, __value_AggregationTemporality, NullableInt32);
OtlpJsonSerializerContext.OtlpExportLogsServiceResponseJson.g.cs (1)
90global::System.Text.Json.JsonSerializer.Serialize(writer, __value_PartialSuccess, OtlpExportLogsPartialSuccessJson);
OtlpJsonSerializerContext.OtlpExportMetricsServiceResponseJson.g.cs (1)
90global::System.Text.Json.JsonSerializer.Serialize(writer, __value_PartialSuccess, OtlpExportMetricsPartialSuccessJson);
OtlpJsonSerializerContext.OtlpExportTraceServiceResponseJson.g.cs (1)
90global::System.Text.Json.JsonSerializer.Serialize(writer, __value_PartialSuccess, OtlpExportTracePartialSuccessJson);
OtlpJsonSerializerContext.OtlpHistogramDataPointJsonArray.g.cs (1)
57global::System.Text.Json.JsonSerializer.Serialize(writer, value[i], OtlpHistogramDataPointJson);
OtlpJsonSerializerContext.OtlpHistogramJson.g.cs (1)
116global::System.Text.Json.JsonSerializer.Serialize(writer, __value_AggregationTemporality, NullableInt32);
OtlpJsonSerializerContext.OtlpKeyValueJson.g.cs (1)
115global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Value, OtlpAnyValueJson);
OtlpJsonSerializerContext.OtlpLogRecordJsonArray.g.cs (1)
57global::System.Text.Json.JsonSerializer.Serialize(writer, value[i], OtlpLogRecordJson);
OtlpJsonSerializerContext.OtlpNumberDataPointJsonArray.g.cs (1)
57global::System.Text.Json.JsonSerializer.Serialize(writer, value[i], OtlpNumberDataPointJson);
OtlpJsonSerializerContext.OtlpSpanEventJsonArray.g.cs (1)
57global::System.Text.Json.JsonSerializer.Serialize(writer, value[i], OtlpSpanEventJson);
OtlpJsonSerializerContext.OtlpSpanJsonArray.g.cs (1)
57global::System.Text.Json.JsonSerializer.Serialize(writer, value[i], OtlpSpanJson);
OtlpJsonSerializerContext.OtlpSpanLinkJson.g.cs (1)
216global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Flags, NullableUInt32);
OtlpJsonSerializerContext.OtlpSpanStatusJson.g.cs (1)
115global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Code, NullableInt32);
OtlpJsonSerializerContext.OtlpSumJson.g.cs (1)
136global::System.Text.Json.JsonSerializer.Serialize(writer, __value_AggregationTemporality, NullableInt32);
OtlpJsonSerializerContext.OtlpSummaryDataPointJsonArray.g.cs (1)
57global::System.Text.Json.JsonSerializer.Serialize(writer, value[i], OtlpSummaryDataPointJson);
ResourceJsonSerializerContext.ResourceJson.g.cs (4)
500global::System.Text.Json.JsonSerializer.Serialize(writer, __value_CreationTimestamp, NullableDateTimeOffset); 506global::System.Text.Json.JsonSerializer.Serialize(writer, __value_StartTimestamp, NullableDateTimeOffset); 512global::System.Text.Json.JsonSerializer.Serialize(writer, __value_StopTimestamp, NullableDateTimeOffset); 523global::System.Text.Json.JsonSerializer.Serialize(writer, __value_ExitCode, NullableInt32);
Aspire.Dashboard.Components.Tests (3)
Controls\GenAIVisualizerDialogTests.cs (3)
61var systemInstruction = JsonSerializer.Serialize(new List<MessagePart> 66var inputMessages = JsonSerializer.Serialize(new List<ChatMessage> 85var outputMessages = JsonSerializer.Serialize(new List<ChatMessage>
Aspire.Dashboard.Tests (55)
Integration\McpConfigurationTests.cs (3)
46var json = JsonSerializer.Serialize(configModel, McpConfigFileModelContext.Default.McpJsonFileServerModel); 108var json = JsonSerializer.Serialize(model, McpInstallButtonModelContext.Default.McpInstallButtonServerModel); 155var json = JsonSerializer.Serialize(configModel, McpConfigFileModelContext.Default.McpJsonFileServerModel);
Integration\OtlpHttpJsonTests.cs (4)
424var response = System.Text.Json.JsonSerializer.Deserialize(responseBody, OtlpJsonSerializerContext.Default.OtlpExportTraceServiceResponseJson); 485var response = System.Text.Json.JsonSerializer.Deserialize(responseBody, OtlpJsonSerializerContext.Default.OtlpExportLogsServiceResponseJson); 562var response = System.Text.Json.JsonSerializer.Deserialize(responseBody, OtlpJsonSerializerContext.Default.OtlpExportLogsServiceResponseJson); 612var response = System.Text.Json.JsonSerializer.Deserialize(responseBody, OtlpJsonSerializerContext.Default.OtlpExportMetricsServiceResponseJson);
Integration\OtlpHttpServiceTests.cs (1)
279var statusResponse = JsonSerializer.Deserialize<StatusResponse>(responseBody, new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });
Mcp\McpConfigModelTests.cs (5)
45var json = JsonSerializer.Serialize(model, McpConfigFileModelContext.Default.McpJsonFileServerModel); 75var json = JsonSerializer.Serialize(model, McpConfigFileModelContext.Default.McpJsonFileServerModel); 109var json = JsonSerializer.Serialize(model, McpInstallButtonModelContext.Default.McpInstallButtonServerModel); 135var json = JsonSerializer.Serialize(model, McpInstallButtonModelContext.Default.McpInstallButtonServerModel); 154var json = JsonSerializer.Serialize(input, McpInstallButtonModelContext.Default.McpInputModel);
Model\ConsoleLogsFiltersTests.cs (2)
26var json = JsonSerializer.Serialize(filters); 27var deserialized = JsonSerializer.Deserialize<ConsoleLogsFilters>(json)!;
Model\GenAIVisualizerDialogViewModelTests.cs (15)
163message: JsonSerializer.Serialize(new SystemOrUserEvent { Content = "System!" }, GenAIEventsContext.Default.SystemOrUserEvent), 169message: JsonSerializer.Serialize(new SystemOrUserEvent { Content = "User!" }, GenAIEventsContext.Default.SystemOrUserEvent), 175message: JsonSerializer.Serialize(new AssistantEvent { Content = "Assistant!" }, GenAIEventsContext.Default.AssistantEvent), 298KeyValuePair.Create(GenAIHelpers.GenAIEventContent, JsonSerializer.Serialize(new SystemOrUserEvent { Content = "System!" }, GenAIEventsContext.Default.SystemOrUserEvent)), 305KeyValuePair.Create(GenAIHelpers.GenAIEventContent, JsonSerializer.Serialize(new SystemOrUserEvent { Content = "User!" }, GenAIEventsContext.Default.SystemOrUserEvent)), 312KeyValuePair.Create(GenAIHelpers.GenAIEventContent, JsonSerializer.Serialize(new AssistantEvent { Content = "Assistant!" }, GenAIEventsContext.Default.AssistantEvent)), 318KeyValuePair.Create(GenAIHelpers.GenAIEventContent, JsonSerializer.Serialize(new AssistantEvent { Content = "Assistant!" }, GenAIEventsContext.Default.AssistantEvent)), 488var systemInstruction = JsonSerializer.Serialize(new List<MessagePart> 493var inputMessages = JsonSerializer.Serialize(new List<ChatMessage> 512var outputMessages = JsonSerializer.Serialize(new List<ChatMessage> 611var systemInstruction = JsonSerializer.Serialize(new List<MessagePart> 616var inputMessages = JsonSerializer.Serialize(new List<ChatMessage> 684var systemInstruction = JsonSerializer.Serialize(new List<MessagePart> 689var inputMessages = JsonSerializer.Serialize(new List<ChatMessage> 708var outputMessages = JsonSerializer.Serialize(new List<ChatMessage>
Model\TelemetryExportServiceTests.cs (12)
662var logsData = await JsonSerializer.DeserializeAsync(logStream, OtlpJsonSerializerContext.Default.OtlpTelemetryDataJson); 670var tracesData = await JsonSerializer.DeserializeAsync(traceStream, OtlpJsonSerializerContext.Default.OtlpTelemetryDataJson); 678var metricsData = await JsonSerializer.DeserializeAsync(metricsStream, OtlpJsonSerializerContext.Default.OtlpTelemetryDataJson); 843var logsData = JsonSerializer.Deserialize(jsonContent, OtlpJsonSerializerContext.Default.OtlpTelemetryDataJson); 896var data = JsonSerializer.Deserialize(json, OtlpJsonSerializerContext.Default.OtlpTelemetryDataJson); 949var data = JsonSerializer.Deserialize(json, OtlpJsonSerializerContext.Default.OtlpTelemetryDataJson); 1009var data = JsonSerializer.Deserialize(json, OtlpJsonSerializerContext.Default.OtlpTelemetryDataJson); 1049var data = JsonSerializer.Deserialize(json, OtlpJsonSerializerContext.Default.OtlpTelemetryDataJson); 1085var data = JsonSerializer.Deserialize(json, OtlpJsonSerializerContext.Default.OtlpTelemetryDataJson); 1195var deserialized = JsonSerializer.Deserialize(json, ResourceJsonSerializerContext.Default.ResourceJson); 1238var deserialized = JsonSerializer.Deserialize(json, ResourceJsonSerializerContext.Default.ResourceJson); 1271var deserialized = JsonSerializer.Deserialize(json, ResourceJsonSerializerContext.Default.ResourceJson);
Model\TelemetryImportServiceTests.cs (6)
294var jsonString = JsonSerializer.Serialize(exportedJson, OtlpJsonSerializerContext.DefaultOptions); 351var jsonString = JsonSerializer.Serialize(exportedJson, OtlpJsonSerializerContext.DefaultOptions); 406var jsonString = JsonSerializer.Serialize(exportedJson, OtlpJsonSerializerContext.DefaultOptions); 464return JsonSerializer.Serialize(telemetryData, OtlpJsonSerializerContext.IndentedOptions); 512return JsonSerializer.Serialize(telemetryData, OtlpJsonSerializerContext.IndentedOptions); 564return JsonSerializer.Serialize(telemetryData, OtlpJsonSerializerContext.IndentedOptions);
Telemetry\DashboardTelemetrySenderTests.cs (2)
137{ HttpStatusCode.OK, JsonSerializer.Serialize(new TelemetryEnabledResponse(IsEnabled: false)), null, false }, 139{ HttpStatusCode.OK, JsonSerializer.Serialize(new TelemetryEnabledResponse(IsEnabled: true)), HttpStatusCode.OK, true },
Telemetry\DashboardTelemetryServiceTests.cs (3)
110Content = new StringContent(JsonSerializer.Serialize(new TelemetryEnabledResponse(IsEnabled: true)) ?? string.Empty) 125Content = new StringContent(JsonSerializer.Serialize(new TelemetryEventCorrelation { Id = userTaskCorrelationId })) 135Content = new StringContent(JsonSerializer.Serialize(new TelemetryEventCorrelation { Id = Guid.NewGuid() }))
TelemetryApiServiceTests.cs (2)
151var json = System.Text.Json.JsonSerializer.Serialize(result.Data); 192var json = System.Text.Json.JsonSerializer.Serialize(result.Data);
Aspire.EndToEnd.Tests (1)
tests\Shared\TemplatesTesting\ProjectInfo.cs (1)
60JsonSerializer.Deserialize<Dictionary<string, ProjectInfo>>(json)!;
Aspire.Hosting (19)
ApplicationModel\Docker\DockerfileStatements.cs (2)
169var commandJson = JsonSerializer.Serialize(_command, options); 240var commandJson = JsonSerializer.Serialize(_command, options);
Backchannel\AuxiliaryBackchannelRpcTarget.cs (2)
785logger.LogDebug("Invoking tool {Name} with arguments {Arguments}", toolName, JsonSerializer.Serialize(arguments)); 792logger.LogDebug("Result: {Result}", JsonSerializer.Serialize(result));
Dashboard\DashboardEventHandlers.cs (2)
233File.WriteAllText(customConfigPath, JsonSerializer.Serialize(defaultConfig, new JsonSerializerOptions { WriteIndented = true })); 821logMessage = JsonSerializer.Deserialize(content, DashboardLogMessageContext.Default.DashboardLogMessage);
Dcp\DcpDependencyCheck.cs (1)
102var dcpInfo = JsonSerializer.Deserialize<DcpInfo>(output);
Dcp\DcpExecutor.cs (4)
494var serviceProducerAnnotations = JsonSerializer.Deserialize<ServiceProducerAnnotation[]>(servicesProducedAnnotationJson); 2372var current = JsonSerializer.SerializeToNode(obj); 2374var copy = JsonSerializer.Deserialize<T>(current)!; 2377var changed = JsonSerializer.SerializeToNode(copy);
Dcp\Model\ModelCommon.cs (4)
75Metadata.Annotations[annotationName] = JsonSerializer.Serialize<List<TValue>>(list.ToList()); 101list = JsonSerializer.Deserialize<List<TValue>>(annotationValue); 118values = JsonSerializer.Deserialize<List<TValue>>(annotationVal) ?? new(); 135var newAnnotationVal = JsonSerializer.Serialize<List<TValue>>(values);
LaunchSettingsSerializerContext.LaunchProfile.g.cs (2)
219global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Aspire.Hosting.LaunchProfile)value).DotnetRunMessages, NullableBoolean); 221global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Aspire.Hosting.LaunchProfile)value).LaunchBrowser, NullableBoolean);
src\Shared\LaunchProfiles\LaunchProfileExtensions.cs (1)
116var settings = JsonSerializer.Deserialize(stream, LaunchSettingsSerializerContext.Default.LaunchSettings);
Utils\ExtensionUtils.cs (1)
30if (configuration[KnownConfigNames.DebugSessionInfo] is { } debugSessionInfoJson && JsonSerializer.Deserialize<RunSessionInfo>(debugSessionInfoJson) is { } debugSessionInfo)
Aspire.Hosting.Azure (2)
AcrLoginService.cs (1)
124var tokenResponse = JsonSerializer.Deserialize<AcrRefreshTokenResponse>(responseBody, s_jsonOptions);
AzureBicepResource.cs (1)
254JsonSerializer.Serialize(context.Writer, inputValue);
Aspire.Hosting.Azure.Functions (3)
LaunchSettingsSerializerContext.LaunchProfile.g.cs (2)
219global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Aspire.Hosting.LaunchProfile)value).DotnetRunMessages, NullableBoolean); 221global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Aspire.Hosting.LaunchProfile)value).LaunchBrowser, NullableBoolean);
src\Shared\LaunchProfiles\LaunchProfileExtensions.cs (1)
116var settings = JsonSerializer.Deserialize(stream, LaunchSettingsSerializerContext.Default.LaunchSettings);
Aspire.Hosting.Azure.ServiceBus (1)
AzureServiceBusRule.cs (1)
139JsonSerializer.Serialize(writer, rule.CorrelationFilter.Properties);
Aspire.Hosting.Azure.Tests (8)
DefaultUserPrincipalProviderTests.cs (6)
98var header = Convert.ToBase64String(Encoding.UTF8.GetBytes(JsonSerializer.Serialize(new { alg = "RS256", typ = "JWT" }))); 108var payloadJson = JsonSerializer.Serialize(payload); 121var header = Convert.ToBase64String(Encoding.UTF8.GetBytes(JsonSerializer.Serialize(new { alg = "RS256", typ = "JWT" }))); 131var payloadJson = JsonSerializer.Serialize(payload); 191var header = Convert.ToBase64String(Encoding.UTF8.GetBytes(JsonSerializer.Serialize(new { alg = "RS256", typ = "JWT" }))); 201var payloadJson = JsonSerializer.Serialize(payload);
ProvisioningTestHelpers.cs (2)
148var headerJson = JsonSerializer.Serialize(new { alg = "RS256", typ = "JWT" }); 162var payloadJson = JsonSerializer.Serialize(payload);
Aspire.Hosting.DevTunnels (1)
DevTunnelCliClient.cs (1)
303var result = JsonSerializer.Deserialize<T>(output, _jsonOptions);
Aspire.Hosting.Docker (3)
DockerComposeJsonContext.DockerComposePublisher.g.cs (2)
102global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Aspire.Hosting.Docker.DockerComposeServiceResource.DockerComposePublisher)value).PublishedPort, NullableInt32); 104global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Aspire.Hosting.Docker.DockerComposeServiceResource.DockerComposePublisher)value).TargetPort, NullableInt32);
DockerComposeServiceResource.cs (1)
438var serviceInfo = JsonSerializer.Deserialize(line, DockerComposeJsonContext.Default.DockerComposeServiceInfo);
Aspire.Hosting.GitHub.Models (2)
GitHubModelsHealthCheck.cs (2)
52var jsonPayload = JsonSerializer.Serialize(payload); 79errorResponse = JsonSerializer.Deserialize<GitHubErrorResponse>(content);
Aspire.Hosting.OpenAI (1)
OpenAIModelHealthCheck.cs (1)
71errorResponse = JsonSerializer.Deserialize<OpenAIErrorResponse>(content);
Aspire.Hosting.Python.Tests (4)
AddPythonAppTests.cs (4)
1383builder.Configuration["DEBUG_SESSION_INFO"] = JsonSerializer.Serialize(runSessionInfo); 1421builder.Configuration["DEBUG_SESSION_INFO"] = JsonSerializer.Serialize(runSessionInfo); 1461builder.Configuration["DEBUG_SESSION_INFO"] = JsonSerializer.Serialize(runSessionInfo); 1498builder.Configuration["DEBUG_SESSION_INFO"] = JsonSerializer.Serialize(runSessionInfo);
Aspire.Hosting.Testing (3)
DistributedApplicationFactory.cs (1)
361var settings = JsonSerializer.Deserialize(stream, LaunchSettingsSerializerContext.Default.LaunchSettings);
LaunchSettingsSerializerContext.LaunchProfile.g.cs (2)
219global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Aspire.Hosting.LaunchProfile)value).DotnetRunMessages, NullableBoolean); 221global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Aspire.Hosting.LaunchProfile)value).LaunchBrowser, NullableBoolean);
Aspire.Hosting.Tests (18)
Dashboard\DashboardLifecycleHookTests.cs (7)
307File.WriteAllText(runtimeConfig, JsonSerializer.Serialize(originalConfig, new JsonSerializerOptions { WriteIndented = true })); 337var customConfig = JsonSerializer.Deserialize<JsonElement>(customConfigContent); 395File.WriteAllText(runtimeConfig, JsonSerializer.Serialize(originalConfig, new JsonSerializerOptions { WriteIndented = true })); 467File.WriteAllText(runtimeConfig, JsonSerializer.Serialize(originalConfig, new JsonSerializerOptions { WriteIndented = true })); 537File.WriteAllText(runtimeConfig, JsonSerializer.Serialize(originalConfig, new JsonSerializerOptions { WriteIndented = true })); 614var messageJson = JsonSerializer.Serialize(message, DashboardLogMessageContext.Default.DashboardLogMessage); 641messageJson = JsonSerializer.Serialize(message, DashboardLogMessageContext.Default.DashboardLogMessage);
Dashboard\DashboardResourceTests.cs (1)
586logger.Log(logLevel, 0, JsonSerializer.Serialize(dashboardLogMessage), null, (s, _) => s);
Dcp\DcpExecutorTests.cs (7)
1383var serviceProducers = JsonSerializer.Deserialize<List<ServiceProducerAnnotation>>(annotations[CustomResource.ServiceProducerAnnotation]); 1668[KnownConfigNames.DebugSessionInfo] = JsonSerializer.Serialize(new RunSessionInfo { ProtocolsSupported = ["test"], SupportedLaunchConfigurations = ["test"] }), 1719[KnownConfigNames.DebugSessionInfo] = JsonSerializer.Serialize(new RunSessionInfo { ProtocolsSupported = ["test"], SupportedLaunchConfigurations = ["other_executable"] }), 1875[KnownConfigNames.DebugSessionInfo] = JsonSerializer.Serialize(runSessionInfo), 1917[KnownConfigNames.DebugSessionInfo] = JsonSerializer.Serialize(runSessionInfo), 1959[KnownConfigNames.DebugSessionInfo] = JsonSerializer.Serialize(runSessionInfo), 2076[KnownConfigNames.DebugSessionInfo] = JsonSerializer.Serialize(runSessionInfo),
Dcp\TestKubernetesService.cs (2)
63var serialized = JsonSerializer.Serialize(r); 64var clone = JsonSerializer.Deserialize<T>(serialized);
LaunchSettingsSerializerContextTests.cs (1)
32JsonSerializer.Deserialize(launchSettingsJson, LaunchSettingsSerializerContext.Default.LaunchSettings);
Aspire.Hosting.Yarp (3)
YarpJsonConfigGeneratorBuilder.cs (3)
88var content = JsonSerializer.Serialize(jsonObject, _serializerOptions); 100var node = JsonSerializer.SerializeToNode(route, _serializerOptions); 114var node = JsonSerializer.SerializeToNode(cluster, _serializerOptions);
Aspire.Templates.Tests (1)
tests\Shared\TemplatesTesting\ProjectInfo.cs (1)
60JsonSerializer.Deserialize<Dictionary<string, ProjectInfo>>(json)!;
aspire-nuget (1)
Commands\SearchCommand.cs (1)
288Console.WriteLine(JsonSerializer.Serialize(result, SearchJsonContext.Default.SearchResult));
aspire-server (4)
Ats\AtsMarshaller.cs (3)
173var json = JsonSerializer.Serialize(value, s_jsonOptions); 433return JsonSerializer.Deserialize(jsonObj.ToJsonString(), targetType, s_jsonOptions); 527return JsonSerializer.Deserialize(value.ToJsonString(), targetType, s_jsonOptions);
Ats\CapabilityDispatcher.cs (1)
618return JsonSerializer.Deserialize<T>(obj.ToJsonString(), s_jsonOptions);
AzureSearch.ApiService (1)
Program.cs (1)
149var hotels = await JsonSerializer.DeserializeAsync<List<Hotel>>(openStream, cancellationToken: cancellationToken);
BasketService (3)
BasketService.cs (1)
88body: JsonSerializer.SerializeToUtf8Bytes(order));
Repositories\RedisBasketRepository.cs (2)
39return JsonSerializer.Deserialize<CustomerBasket>(data.ToString(), s_jsonSerializerOptions); 49var created = await _database.StringSetAsync(basket.BuyerId, JsonSerializer.Serialize(basket, s_jsonSerializerOptions));
BicepSample.ApiService (5)
Program.cs (5)
104await database.ListRightPushAsync("entries", JsonSerializer.SerializeToUtf8Bytes(entry)); 111entries.Add(JsonSerializer.Deserialize<Entry>((string)item!)!); 135entries.Add(JsonSerializer.Deserialize<Entry>(content)!); 151{ "data", JsonSerializer.Serialize(entry) } 160entries.Add(JsonSerializer.Deserialize<Entry>((string)item["data"])!);
CdkSample.ApiService (2)
Program.cs (2)
67await database.ListRightPushAsync("entries", JsonSerializer.SerializeToUtf8Bytes(entry)); 74entries.Add(JsonSerializer.Deserialize<Entry>((string)item!)!);
ConfigurationSchemaGenerator (1)
ConfigSchemaEmitter.cs (1)
48return JsonSerializer.Serialize(root, s_serializerOptions);
dotnet-dev-certs (1)
Program.cs (1)
371reporter.Output(JsonSerializer.Serialize(certReports, options: new JsonSerializerOptions { WriteIndented = true }));
dotnet-user-jwts (12)
Commands\CreateCommand.cs (1)
274reporter.Output(JsonSerializer.Serialize(jwt, JwtSerializerOptions.Default));
Commands\ListCommand.cs (2)
57reporter.Output(JsonSerializer.Serialize(jwts, JwtSerializerOptions.Default)); 61reporter.Output(JsonSerializer.Serialize(Array.Empty<Jwt>(), JwtSerializerOptions.Default));
Helpers\DevJwtCliHelpers.cs (1)
167reporter.Output(JsonSerializer.Serialize(jwt, JwtSerializerOptions.Default));
Helpers\JwtAuthenticationSchemeSettings.cs (4)
19var config = JsonSerializer.Deserialize<JsonObject>(reader, JwtSerializerOptions.Default); 61JsonSerializer.Serialize(writer, config, JwtSerializerOptions.Default); 67var config = JsonSerializer.Deserialize<JsonObject>(reader, JwtSerializerOptions.Default); 77JsonSerializer.Serialize(writer, config, JwtSerializerOptions.Default);
Helpers\JwtStore.cs (2)
33Jwts = JsonSerializer.Deserialize<IDictionary<string, Jwt>>(fileStream, JwtSerializerOptions.Default) ?? new Dictionary<string, Jwt>(); 50JsonSerializer.Serialize(fileStream, Jwts);
Helpers\SigningKeysHandler.cs (2)
71secrets = JsonSerializer.Deserialize<JsonObject>(secretsFileStream, JwtSerializerOptions.Default); 96JsonSerializer.Serialize(secretsWriteStream, secrets);
IdentitySample.PasskeyConformance (4)
Program.cs (4)
71var stateJson = JsonSerializer.Serialize(state, JsonSerializerOptions.Web); 90var state = JsonSerializer.Deserialize<PasskeyAttestationState>(stateJson, JsonSerializerOptions.Web); 160var stateJson = JsonSerializer.Serialize(state, JsonSerializerOptions.Web); 177var state = JsonSerializer.Deserialize<PasskeyAssertionState>(stateJson, JsonSerializerOptions.Web);
InMemory.FunctionalTests (1)
EventSourceTests.cs (1)
460_logger?.LogInformation("{event}", JsonSerializer.Serialize(eventData, new JsonSerializerOptions
Microsoft.AspNetCore.Authentication.Core.Test (4)
AuthenticationPropertiesTests.cs (4)
321var json = JsonSerializer.Serialize(props); 328var deserialized = JsonSerializer.Deserialize<AuthenticationProperties>(json); 352var deserialized = JsonSerializer.Deserialize<AuthenticationProperties>(json); 376var json = JsonSerializer.Serialize(props, options);
Microsoft.AspNetCore.Authentication.JwtBearer.Tools.Tests (13)
UserJwtsTests.cs (13)
112var appSettings = JsonSerializer.Deserialize<JsonObject>(File.ReadAllText(appsettings)); 115appSettings = JsonSerializer.Deserialize<JsonObject>(File.ReadAllText(appsettings)); 129var appSettings = JsonSerializer.Deserialize<JsonObject>(File.ReadAllText(appsettings)); 132appSettings = JsonSerializer.Deserialize<JsonObject>(File.ReadAllText(appsettings)); 173var deserialized = JsonSerializer.Deserialize<Dictionary<string, Jwt>>(output); 300var secretsJson = await JsonSerializer.DeserializeAsync<JsonObject>(openStream); 407var deserialized = JsonSerializer.Deserialize<Jwt>(output); 465var deserialized = JsonSerializer.Deserialize<Jwt>(output); 519var secretsJson = await JsonSerializer.DeserializeAsync<JsonObject>(openStream); 547var secretsJson = await JsonSerializer.DeserializeAsync<JsonObject>(openStream); 586var secretsJson = await JsonSerializer.DeserializeAsync<JsonObject>(openStream); 608var secretsJson = await JsonSerializer.DeserializeAsync<JsonObject>(openStream); 630var secretsJson = await JsonSerializer.DeserializeAsync<JsonObject>(openStream);
Microsoft.AspNetCore.Authentication.Test (1)
OAuthTests.cs (1)
543var text = JsonSerializer.Serialize(content);
Microsoft.AspNetCore.Authentication.Twitter (1)
TwitterHandler.cs (1)
371errorResponse = await JsonSerializer.DeserializeAsync(errorContentStream, TwitterJsonContext.DefaultWithOptions.TwitterErrorResponse);
Microsoft.AspNetCore.Components (4)
PersistentComponentState.cs (4)
118if (!_currentState.TryAdd(key, JsonSerializer.SerializeToUtf8Bytes(instance, JsonSerializerOptionsProvider.Options))) 134if (!_currentState.TryAdd(key, JsonSerializer.SerializeToUtf8Bytes(instance, type, JsonSerializerOptionsProvider.Options))) 177instance = JsonSerializer.Deserialize<TValue>(ref reader, JsonSerializerOptionsProvider.Options)!; 195instance = JsonSerializer.Deserialize(ref reader, type, JsonSerializerOptionsProvider.Options);
Microsoft.AspNetCore.Components.Endpoints (23)
Assets\ImportMapDefinition.cs (1)
208_json ??= JsonSerializer.Serialize(this, ImportMapSerializerContext.CustomEncoder.Options);
Builder\ResourceCollectionUrlEndpoint.cs (1)
100JsonSerializer.Serialize<IReadOnlyList<ResourceAsset>>(utf8Writer, resourceCollection, ResourceCollectionSerializerContext.Default.Options);
DependencyInjection\DefaultRazorComponentsServiceOptionsConfiguration.cs (1)
57var initializers = JsonSerializer.Deserialize<string[]>(options.JavaScriptInitializers);
DependencyInjection\WebAssemblyComponentSerializer.cs (2)
19var serializedDefinitions = Convert.ToBase64String(JsonSerializer.SerializeToUtf8Bytes(definitions, WebAssemblyComponentSerializationSettings.JsonSerializationOptions)); 20var serializedValues = Convert.ToBase64String(JsonSerializer.SerializeToUtf8Bytes(values, WebAssemblyComponentSerializationSettings.JsonSerializationOptions));
JsonTempDataSerializerContext.ICollectionNullableBoolean.g.cs (1)
57global::System.Text.Json.JsonSerializer.Serialize(writer, element, NullableBoolean);
JsonTempDataSerializerContext.ICollectionNullableDateTime.g.cs (1)
57global::System.Text.Json.JsonSerializer.Serialize(writer, element, NullableDateTime);
JsonTempDataSerializerContext.ICollectionNullableGuid.g.cs (1)
57global::System.Text.Json.JsonSerializer.Serialize(writer, element, NullableGuid);
JsonTempDataSerializerContext.ICollectionNullableInt32.g.cs (1)
57global::System.Text.Json.JsonSerializer.Serialize(writer, element, NullableInt32);
JsonTempDataSerializerContext.IDictionaryStringNullableBoolean.g.cs (1)
58global::System.Text.Json.JsonSerializer.Serialize(writer, entry.Value, NullableBoolean);
JsonTempDataSerializerContext.IDictionaryStringNullableDateTime.g.cs (1)
58global::System.Text.Json.JsonSerializer.Serialize(writer, entry.Value, NullableDateTime);
JsonTempDataSerializerContext.IDictionaryStringNullableGuid.g.cs (1)
58global::System.Text.Json.JsonSerializer.Serialize(writer, entry.Value, NullableGuid);
JsonTempDataSerializerContext.IDictionaryStringNullableInt32.g.cs (1)
58global::System.Text.Json.JsonSerializer.Serialize(writer, entry.Value, NullableInt32);
Rendering\EndpointHtmlRenderer.Streaming.cs (3)
291var settingsJson = JsonSerializer.Serialize(settings, ServerComponentSerializationSettings.JsonSerializationOptions); 296var serializedStartRecord = JsonSerializer.Serialize(marker, ServerComponentSerializationSettings.JsonSerializationOptions); 320var serializedEndRecord = JsonSerializer.Serialize(endMarker, ServerComponentSerializationSettings.JsonSerializationOptions);
src\Shared\Components\PrerenderComponentApplicationStore.cs (2)
33var state = JsonSerializer.Deserialize( 53JsonSerializer.SerializeToUtf8Bytes(state);
src\Shared\Components\ServerComponentSerializer.cs (1)
51var serializedServerComponentBytes = JsonSerializer.SerializeToUtf8Bytes(serverComponent, ServerComponentSerializationSettings.JsonSerializationOptions);
TempData\CookieTempDataProvider.cs (2)
75dataFromCookie = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(unprotectBuffer.WrittenSpan); 80dataFromCookie = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(unprotectedBytes);
TempData\JsonTempDataSerializer.cs (1)
151return JsonSerializer.SerializeToUtf8Bytes<IDictionary<string, object?>>(normalizedData, JsonTempDataSerializerContext.Default.Options);
TempData\SessionStorageTempDataProvider.cs (1)
34var dataFromSession = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(value);
Microsoft.AspNetCore.Components.Endpoints.Tests (69)
EndpointHtmlRendererTest.cs (52)
89var marker = JsonSerializer.Deserialize<ComponentMarker>(match.Groups[1].Value, ServerComponentSerializationSettings.JsonSerializationOptions); 180var preambleMarker = JsonSerializer.Deserialize<ComponentMarker>(preamble, ServerComponentSerializationSettings.JsonSerializationOptions); 190var epilogueMarker = JsonSerializer.Deserialize<ComponentMarker>(epilogue, ServerComponentSerializationSettings.JsonSerializationOptions); 223var marker = JsonSerializer.Deserialize<ComponentMarker>(match.Groups[1].Value, ServerComponentSerializationSettings.JsonSerializationOptions); 230JsonSerializer.Deserialize<ComponentParameter[]>(Convert.FromBase64String(marker.ParameterDefinitions), WebAssemblyComponentSerializationSettings.JsonSerializationOptions)); 235var value = Assert.Single(JsonSerializer.Deserialize<object[]>(Convert.FromBase64String(marker.ParameterValues), WebAssemblyComponentSerializationSettings.JsonSerializationOptions)); 261var marker = JsonSerializer.Deserialize<ComponentMarker>(match.Groups[1].Value, ServerComponentSerializationSettings.JsonSerializationOptions); 267var parameterDefinition = Assert.Single(JsonSerializer.Deserialize<ComponentParameter[]>(Convert.FromBase64String(marker.ParameterDefinitions), WebAssemblyComponentSerializationSettings.JsonSerializationOptions)); 272var value = Assert.Single(JsonSerializer.Deserialize<object[]>(Convert.FromBase64String(marker.ParameterValues), WebAssemblyComponentSerializationSettings.JsonSerializationOptions)); 298var preambleMarker = JsonSerializer.Deserialize<ComponentMarker>(preamble, ServerComponentSerializationSettings.JsonSerializationOptions); 304var parameterDefinition = Assert.Single(JsonSerializer.Deserialize<ComponentParameter[]>(Convert.FromBase64String(preambleMarker.ParameterDefinitions), WebAssemblyComponentSerializationSettings.JsonSerializationOptions)); 309var value = Assert.Single(JsonSerializer.Deserialize<object[]>(Convert.FromBase64String(preambleMarker.ParameterValues), WebAssemblyComponentSerializationSettings.JsonSerializationOptions)); 317var epilogueMarker = JsonSerializer.Deserialize<ComponentMarker>(epilogue, ServerComponentSerializationSettings.JsonSerializationOptions); 348var preambleMarker = JsonSerializer.Deserialize<ComponentMarker>(preamble, ServerComponentSerializationSettings.JsonSerializationOptions); 354var parameterDefinition = Assert.Single(JsonSerializer.Deserialize<ComponentParameter[]>(Convert.FromBase64String(preambleMarker.ParameterDefinitions), WebAssemblyComponentSerializationSettings.JsonSerializationOptions)); 359var value = Assert.Single(JsonSerializer.Deserialize<object[]>(Convert.FromBase64String(preambleMarker.ParameterValues), WebAssemblyComponentSerializationSettings.JsonSerializationOptions)); 366var epilogueMarker = JsonSerializer.Deserialize<ComponentMarker>(epilogue, ServerComponentSerializationSettings.JsonSerializationOptions); 406var marker = JsonSerializer.Deserialize<ComponentMarker>(match.Groups[1].Value, ServerComponentSerializationSettings.JsonSerializationOptions); 413var serverComponent = JsonSerializer.Deserialize<ServerComponent>(unprotectedServerComponent, ServerComponentSerializationSettings.JsonSerializationOptions); 439var preambleMarker = JsonSerializer.Deserialize<ComponentMarker>(preamble, ServerComponentSerializationSettings.JsonSerializationOptions); 446var serverComponent = JsonSerializer.Deserialize<ServerComponent>(unprotectedServerComponent, ServerComponentSerializationSettings.JsonSerializationOptions); 457var epilogueMarker = JsonSerializer.Deserialize<ComponentMarker>(epilogue, ServerComponentSerializationSettings.JsonSerializationOptions); 504var preambleMarker = JsonSerializer.Deserialize<ComponentMarker>(preamble, ServerComponentSerializationSettings.JsonSerializationOptions); 509var firstServerComponent = JsonSerializer.Deserialize<ServerComponent>(unprotectedFirstServerComponent, ServerComponentSerializationSettings.JsonSerializationOptions); 515var markerMarker = JsonSerializer.Deserialize<ComponentMarker>(marker, ServerComponentSerializationSettings.JsonSerializationOptions); 520var secondServerComponent = JsonSerializer.Deserialize<ServerComponent>(unprotectedSecondServerComponent, ServerComponentSerializationSettings.JsonSerializationOptions); 557var marker = JsonSerializer.Deserialize<ComponentMarker>(match.Groups[1].Value, ServerComponentSerializationSettings.JsonSerializationOptions); 564var serverComponent = JsonSerializer.Deserialize<ServerComponent>(unprotectedServerComponent, ServerComponentSerializationSettings.JsonSerializationOptions); 596var marker = JsonSerializer.Deserialize<ComponentMarker>(match.Groups[1].Value, ServerComponentSerializationSettings.JsonSerializationOptions); 603var serverComponent = JsonSerializer.Deserialize<ServerComponent>(unprotectedServerComponent, ServerComponentSerializationSettings.JsonSerializationOptions); 636var preambleMarker = JsonSerializer.Deserialize<ComponentMarker>(preamble, ServerComponentSerializationSettings.JsonSerializationOptions); 643var serverComponent = JsonSerializer.Deserialize<ServerComponent>(unprotectedServerComponent, ServerComponentSerializationSettings.JsonSerializationOptions); 663var epilogueMarker = JsonSerializer.Deserialize<ComponentMarker>(epilogue, ServerComponentSerializationSettings.JsonSerializationOptions); 687var preambleMarker = JsonSerializer.Deserialize<ComponentMarker>(preamble, ServerComponentSerializationSettings.JsonSerializationOptions); 694var serverComponent = JsonSerializer.Deserialize<ServerComponent>(unprotectedServerComponent, ServerComponentSerializationSettings.JsonSerializationOptions); 714var epilogueMarker = JsonSerializer.Deserialize<ComponentMarker>(epilogue, ServerComponentSerializationSettings.JsonSerializationOptions); 754var marker = JsonSerializer.Deserialize<ComponentMarker>(match.Groups[1].Value, ServerComponentSerializationSettings.JsonSerializationOptions); 761var serverComponent = JsonSerializer.Deserialize<ServerComponent>(unprotectedServerComponent, ServerComponentSerializationSettings.JsonSerializationOptions); 794var preambleMarker = JsonSerializer.Deserialize<ComponentMarker>(preamble, ServerComponentSerializationSettings.JsonSerializationOptions); 801var serverComponent = JsonSerializer.Deserialize<ServerComponent>(unprotectedServerComponent, ServerComponentSerializationSettings.JsonSerializationOptions); 812var epilogueMarker = JsonSerializer.Deserialize<ComponentMarker>(epilogue, ServerComponentSerializationSettings.JsonSerializationOptions); 834var preambleMarker = JsonSerializer.Deserialize<ComponentMarker>(preamble, ServerComponentSerializationSettings.JsonSerializationOptions); 844var epilogueMarker = JsonSerializer.Deserialize<ComponentMarker>(epilogue, ServerComponentSerializationSettings.JsonSerializationOptions); 1345var marker = JsonSerializer.Deserialize<ComponentMarker>(markerText, ServerComponentSerializationSettings.JsonSerializationOptions); 1352var serverComponent = JsonSerializer.Deserialize<ServerComponent>(unprotectedServerComponent, ServerComponentSerializationSettings.JsonSerializationOptions); 1374var marker = JsonSerializer.Deserialize<ComponentMarker>(markerText, ServerComponentSerializationSettings.JsonSerializationOptions); 1381var serverComponent = JsonSerializer.Deserialize<ServerComponent>(unprotectedServerComponent, ServerComponentSerializationSettings.JsonSerializationOptions); 1402var marker = JsonSerializer.Deserialize<ComponentMarker>(markerText, ServerComponentSerializationSettings.JsonSerializationOptions); 1405var parameterValues = JsonSerializer.Deserialize<object[]>(Convert.FromBase64String(marker.ParameterValues), WebAssemblyComponentSerializationSettings.JsonSerializationOptions); 1415var marker = JsonSerializer.Deserialize<ComponentMarker>(markerText, ServerComponentSerializationSettings.JsonSerializationOptions); 1418var parameterValues = JsonSerializer.Deserialize<object[]>(Convert.FromBase64String(marker.ParameterValues), WebAssemblyComponentSerializationSettings.JsonSerializationOptions); 1446var preambleMarker = JsonSerializer.Deserialize<ComponentMarker>(preamble, ServerComponentSerializationSettings.JsonSerializationOptions);
TempData\JsonTempDataSerializerTest.cs (16)
118var jsonDocument = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(serialized); 136var jsonDocument = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(serialized); 154var jsonDocument = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(serialized); 173var jsonDocument = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(serialized); 192var jsonDocument = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(serialized); 211var jsonDocument = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(serialized); 229var jsonDocument = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(serialized); 251var jsonDocument = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(serialized); 270var jsonDocument = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(serialized); 291var jsonDocument = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(serialized); 312var jsonDocument = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(serialized); 333var jsonDocument = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(serialized); 353var jsonDocument = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(serialized); 375var jsonDocument = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(serialized); 397var jsonDocument = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(serialized); 418var jsonDocument = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(serialized);
WebRootComponentParametersTest.cs (1)
179var jsonElement = JsonSerializer.SerializeToElement(parameterValues[i]);
Microsoft.AspNetCore.Components.Server (14)
CircuitPersistenceManagerSerializerContext.ComponentMarker.g.cs (2)
245global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Microsoft.AspNetCore.Components.ComponentMarker)value).Key, NullableComponentMarkerKey); 247global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Microsoft.AspNetCore.Components.ComponentMarker)value).Sequence, NullableInt32);
Circuits\CircuitOptionsJavaScriptInitializersConfiguration.cs (1)
24var initializers = JsonSerializer.Deserialize<string[]>(file.CreateReadStream());
Circuits\CircuitPersistenceManager.cs (2)
190return JsonSerializer.Deserialize<Dictionary<int, ComponentMarker>>( 228RootComponents = JsonSerializer.SerializeToUtf8Bytes(
Circuits\ComponentParameterDeserializer.cs (1)
65var parameterValue = JsonSerializer.Deserialize(
Circuits\ServerComponentDeserializer.cs (3)
96var markers = JsonSerializer.Deserialize<IEnumerable<ComponentMarker>>(serializedComponentRecords, ServerComponentSerializationSettings.JsonSerializationOptions); 259result = JsonSerializer.Deserialize<ServerComponent>( 302result = JsonSerializer.Deserialize<RootComponentOperationBatch>(
ProtectedBrowserStorage\ProtectedBrowserStorage.cs (2)
125var json = JsonSerializer.Serialize(value, options: JsonSerializerOptionsProvider.Options); 136return JsonSerializer.Deserialize<TValue>(json, options: JsonSerializerOptionsProvider.Options)!;
src\Shared\Components\PrerenderComponentApplicationStore.cs (2)
33var state = JsonSerializer.Deserialize( 53JsonSerializer.SerializeToUtf8Bytes(state);
src\Shared\Components\ServerComponentSerializer.cs (1)
51var serializedServerComponentBytes = JsonSerializer.SerializeToUtf8Bytes(serverComponent, ServerComponentSerializationSettings.JsonSerializationOptions);
Microsoft.AspNetCore.Components.Server.Tests (7)
Circuits\CircuitHostTest.cs (1)
894var jsonElement = JsonSerializer.SerializeToElement(parameterValues[i]);
Circuits\CircuitPersistenceManagerTest.cs (2)
360var actual = JsonSerializer.Deserialize<Dictionary<int, ComponentMarker>>(rootComponents, SerializerOptions); 545var batchJson = JsonSerializer.Serialize(batch, ServerComponentSerializationSettings.JsonSerializationOptions);
Circuits\RemoteRendererTest.cs (1)
695var jsonElement = JsonSerializer.SerializeToElement(parameterValues[i]);
Circuits\ServerComponentDeserializerTest.cs (3)
496JsonSerializer.Serialize( 501=> JsonSerializer.Serialize(batch, ServerComponentSerializationSettings.JsonSerializationOptions); 513JsonSerializer.Serialize(markers, ServerComponentSerializationSettings.JsonSerializationOptions);
Microsoft.AspNetCore.Components.Tests (33)
BindConverterTest.cs (3)
292var expected = JsonSerializer.Serialize(value); 404return JsonSerializer.Deserialize<Person>(text); 424return JsonSerializer.Serialize((Person)value);
PersistentState\ComponentStatePersistenceManagerTest.cs (3)
46["MyState"] = JsonSerializer.SerializeToUtf8Bytes(data) 131var registration = Assert.Single(JsonSerializer.Deserialize<PersistentService[]>(registrations, JsonSerializerOptions.Web)); 160Assert.Equal(data, JsonSerializer.Deserialize<byte[]>(persisted.ToArray()));
PersistentState\PersistentComponentStateTest.cs (7)
21["MyState"] = JsonSerializer.SerializeToUtf8Bytes(new byte[] { 1, 2, 3, 4 }) 69["MyState"] = JsonSerializer.SerializeToUtf8Bytes(new byte[] { 1, 2, 3, 4 }) 97Assert.Equal(myState, JsonSerializer.Deserialize<byte[]>(stored)); 133Assert.Equal(myState, JsonSerializer.Deserialize<byte[]>(stored)); 151Assert.Null(JsonSerializer.Deserialize<byte[]>(stored)); 159var serialized = JsonSerializer.SerializeToUtf8Bytes(myState); 177var serialized = JsonSerializer.SerializeToUtf8Bytes<byte[]>(null);
PersistentStateValueProviderTests.cs (1)
108dictionary[key] = JsonSerializer.SerializeToUtf8Bytes(item.value, JsonSerializerOptions.Web);
PersistentValueProviderComponentSubscriptionTests.cs (13)
77initialState[key] = JsonSerializer.SerializeToUtf8Bytes("persisted-value", JsonSerializerOptions.Web); 137initialState[key] = JsonSerializer.SerializeToUtf8Bytes(123, JsonSerializerOptions.Web); 167initialState[key] = JsonSerializer.SerializeToUtf8Bytes((int?)456, JsonSerializerOptions.Web); 217initialState[key] = JsonSerializer.SerializeToUtf8Bytes("persisted-value", JsonSerializerOptions.Web); 259appState[key] = JsonSerializer.SerializeToUtf8Bytes("first-persisted-value", JsonSerializerOptions.Web); 278[key] = JsonSerializer.SerializeToUtf8Bytes("second-restored-value", JsonSerializerOptions.Web) 352initialState[stringKey] = JsonSerializer.SerializeToUtf8Bytes("restored-string", JsonSerializerOptions.Web); 353initialState[intKey] = JsonSerializer.SerializeToUtf8Bytes(123, JsonSerializerOptions.Web); 354initialState[boolKey] = JsonSerializer.SerializeToUtf8Bytes(false, JsonSerializerOptions.Web); 410initialState[intKey] = JsonSerializer.SerializeToUtf8Bytes(999, JsonSerializerOptions.Web); 411initialState[nullableIntKey] = JsonSerializer.SerializeToUtf8Bytes((int?)777, JsonSerializerOptions.Web); 603var json = JsonSerializer.SerializeToUtf8Bytes($"CUSTOM:{value.Value}"); 609var json = JsonSerializer.Deserialize<string>(data.ToArray());
ResourceAssetCollectionTest.cs (6)
100var json = JsonSerializer.Serialize(originalAsset, options); 101var deserializedAsset = JsonSerializer.Deserialize<ResourceAsset>(json, options); 121var json = JsonSerializer.Serialize(originalAsset, options); 122var deserializedAsset = JsonSerializer.Deserialize<ResourceAsset>(json, options); 146var json = JsonSerializer.Serialize<IReadOnlyList<ResourceAsset>>(assets, options); 147var deserializedAssets = JsonSerializer.Deserialize<IReadOnlyList<ResourceAsset>>(json, options);
Microsoft.AspNetCore.Components.Web (5)
JSComponents\JSComponentInterop.cs (3)
104ParameterKind.Value => JsonSerializer.Deserialize( 109JsonSerializer.Deserialize<IJSObjectReference>(parameterJsonValue, jsonOptions)), 112JsonSerializer.Deserialize<IJSObjectReference>(parameterJsonValue, jsonOptions)),
WebEventData\WebEventData.cs (1)
79return (EventArgs)JsonSerializer.Deserialize(eventArgsJson.GetRawText(), eventArgsType, jsonSerializerOptions)!;
WebRenderer.cs (1)
129var argsJson = JsonSerializer.Serialize(args, newJsonOptions);
Microsoft.AspNetCore.Components.Web.Tests (12)
WebEventData\ChangeEventArgsReaderTest.cs (1)
65var json = JsonSerializer.SerializeToUtf8Bytes(args, JsonSerializerOptionsProvider.Options);
WebEventData\ClipboardEventArgsReaderTest.cs (1)
29var json = JsonSerializer.SerializeToUtf8Bytes(args, JsonSerializerOptionsProvider.Options);
WebEventData\DragEventArgsReaderTest.cs (1)
83var json = JsonSerializer.SerializeToUtf8Bytes(args, JsonSerializerOptionsProvider.Options);
WebEventData\ErrorEventArgsReaderTest.cs (1)
38var json = JsonSerializer.SerializeToUtf8Bytes(args, JsonSerializerOptionsProvider.Options);
WebEventData\FocusEventArgsReaderTest.cs (1)
30var json = JsonSerializer.SerializeToUtf8Bytes(args, JsonSerializerOptionsProvider.Options);
WebEventData\KeyboardEventArgsReaderTest.cs (1)
48var json = JsonSerializer.SerializeToUtf8Bytes(args, JsonSerializerOptionsProvider.Options);
WebEventData\MouseEventArgsReaderTest.cs (1)
68var json = JsonSerializer.SerializeToUtf8Bytes(args, JsonSerializerOptionsProvider.Options);
WebEventData\PointerEventArgsReaderTest.cs (1)
60var json = JsonSerializer.SerializeToUtf8Bytes(args, JsonSerializerOptionsProvider.Options);
WebEventData\ProgressEventArgsReaderTest.cs (1)
35var json = JsonSerializer.SerializeToUtf8Bytes(args, JsonSerializerOptionsProvider.Options);
WebEventData\TouchEventArgsReaderTest.cs (1)
113var json = JsonSerializer.SerializeToUtf8Bytes(args, JsonSerializerOptionsProvider.Options);
WebEventData\WebEventDescriptorReaderTest.cs (1)
67var json = JsonSerializer.SerializeToUtf8Bytes(args, JsonSerializerOptionsProvider.Options);
WebEventData\WheelEventArgsReaderTest.cs (1)
53var json = JsonSerializer.SerializeToUtf8Bytes(args, JsonSerializerOptionsProvider.Options);
Microsoft.AspNetCore.Components.WebAssembly (10)
Prerendering\WebAssemblyComponentParameterDeserializer.cs (3)
60var parameterValue = JsonSerializer.Deserialize( 81return JsonSerializer.Deserialize(parametersDefinitions, WebAssemblyJsonSerializerContext.Default.ComponentParameterArray)!; 87return JsonSerializer.Deserialize(parameterValues, WebAssemblyJsonSerializerContext.Default.IListObject)!;
Services\DefaultWebAssemblyJSRuntime.cs (1)
117var deserialized = JsonSerializer.Deserialize(
src\Shared\Components\PrerenderComponentApplicationStore.cs (2)
33var state = JsonSerializer.Deserialize( 53JsonSerializer.SerializeToUtf8Bytes(state);
WebAssemblyJsonSerializerContext.ComponentMarker.g.cs (2)
254global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Key, NullableComponentMarkerKey); 260global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Sequence, NullableInt32);
WebAssemblyJsonSerializerContext.RootComponentOperation.g.cs (2)
147global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Microsoft.AspNetCore.Components.RootComponentOperation)value).Type, RootComponentOperationType); 153global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Marker, NullableComponentMarker);
Microsoft.AspNetCore.Components.WebAssembly.Server (2)
TargetPickerUi.cs (2)
53var msg = JsonSerializer.Serialize(args); 448return JsonSerializer.Deserialize<BrowserTab[]>(jsonResponse, JsonOptions)!;
Microsoft.AspNetCore.Components.WebAssembly.Tests (3)
JSObjectReferenceJsonConverterTest.cs (3)
28var deserialized = (JSObjectReference)JsonSerializer.Deserialize<IJSObjectReference>(json, JsonSerializerOptions)!; 42var deserialized = (JSInProcessObjectReference)JsonSerializer.Deserialize<IJSInProcessObjectReference>(json, JsonSerializerOptions)!; 55var deserialized = JsonSerializer.Deserialize<IJSObjectReference>(json, JsonSerializerOptions);
Microsoft.AspNetCore.Components.WebView (7)
IpcCommon.cs (2)
34return $"{_ipcMessagePrefix}{JsonSerializer.Serialize(messageTypeAndArgs, JsonSerializerOptionsProvider.Options)}"; 44var parsed = (JsonElement[])JsonSerializer.Deserialize(messageAfterPrefix, typeof(JsonElement[]), JsonSerializerOptionsProvider.Options);
SourceGenerationContext.DictionaryStringStaticWebAssetNode.g.cs (1)
60global::System.Text.Json.JsonSerializer.Serialize(writer, entry.Value, StaticWebAssetNode);
SourceGenerationContext.IDictionaryStringStaticWebAssetNode.g.cs (1)
60global::System.Text.Json.JsonSerializer.Serialize(writer, entry.Value, StaticWebAssetNode);
SourceGenerationContext.StaticWebAssetManifest.g.cs (1)
115global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Microsoft.AspNetCore.StaticWebAssets.ManifestStaticWebAssetFileProvider.StaticWebAssetManifest)value).Root, StaticWebAssetNode);
src\Shared\StaticWebAssets\ManifestStaticWebAssetFileProvider.cs (2)
319return JsonSerializer.Deserialize( 379var parsed = JsonSerializer.Deserialize(ref reader, SourceGenerationContext.DefaultWithConverter.IDictionaryStringStaticWebAssetNode)!;
Microsoft.AspNetCore.Diagnostics (2)
DeveloperExceptionPage\DeveloperExceptionPageMiddlewareImpl.cs (1)
260problemDetails.Extensions["exception"] = JsonSerializer.SerializeToElement(new ExceptionExtensionData
ExtensionsExceptionJsonContext.ExceptionExtensionData.g.cs (1)
175global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Microsoft.AspNetCore.Diagnostics.ExceptionExtensionData)value).RouteValues, RouteValueDictionary);
Microsoft.AspNetCore.Grpc.JsonTranscoding (17)
Internal\Json\AnyConverter.cs (5)
50data = (IMessage)JsonSerializer.Deserialize(valueField, descriptor.ClrType, options)!; 54data = (IMessage)JsonSerializer.Deserialize(d.RootElement, descriptor.ClrType, options)!; 89JsonSerializer.Serialize(writer, wrappedValue, wrappedValue.GetType(), options); 93JsonSerializer.Serialize(writer, valueMessage, valueMessage.GetType(), options); 118JsonSerializer.Serialize(writer, value, value.GetType(), options);
Internal\Json\JsonConverterHelper.cs (2)
140var newValues = (IDictionary)JsonSerializer.Deserialize(ref reader, repeatedFieldType, options)!; 154var newValues = (IList)JsonSerializer.Deserialize(ref reader, repeatedFieldType, options)!;
Internal\Json\ListValueConverter.cs (1)
30JsonSerializer.Serialize(writer, list, list.GetType(), options);
Internal\Json\StructConverter.cs (1)
41JsonSerializer.Serialize(writer, v, v.GetType(), options);
Internal\Json\ValueConverter.cs (3)
28var structMessage = JsonSerializer.Deserialize(ref reader, field.MessageType.ClrType, options); 35var list = JsonSerializer.Deserialize(ref reader, field.MessageType.ClrType, options); 80JsonSerializer.Serialize(writer, v, v.GetType(), options);
Internal\Json\WrapperConverter.cs (2)
21var value = JsonSerializer.Deserialize(ref reader, t, options); 31JsonSerializer.Serialize(writer, innerValue, innerValue.GetType(), options);
Internal\JsonRequestHelpers.cs (3)
172await JsonSerializer.SerializeAsync(stream, responseBody, options, cancellationToken); 233bodyContent = (await JsonSerializer.DeserializeAsync(stream, type, serializerOptions))!; 245bodyContent = (IMessage)(await JsonSerializer.DeserializeAsync(stream, serverCallContext.DescriptorInfo.BodyDescriptor.ClrType, serializerOptions))!;
Microsoft.AspNetCore.Grpc.JsonTranscoding.Tests (5)
ConverterTests\JsonConverterReadTests.cs (2)
857var objectNew = JsonSerializer.Deserialize<TValue>(value, jsonSerializerOptions)!; 885var ex = Assert.ThrowsAny<Exception>(() => JsonSerializer.Deserialize<TValue>(value, jsonSerializerOptions));
ConverterTests\JsonConverterWriteTests.cs (3)
250var json = JsonSerializer.Serialize(v, jsonSerializerOptions); 265var json = JsonSerializer.Serialize(v, jsonSerializerOptions); 611var jsonNew = JsonSerializer.Serialize(value, jsonSerializerOptions);
Microsoft.AspNetCore.Grpc.Microbenchmarks (2)
Json\JsonReading.cs (1)
35JsonSerializer.Deserialize(_requestJson, typeof(HelloRequest), _serializerOptions);
Json\JsonWriting.cs (1)
36JsonSerializer.Serialize(_request, _serializerOptions);
Microsoft.AspNetCore.Hosting (5)
SourceGenerationContext.DictionaryStringStaticWebAssetNode.g.cs (1)
60global::System.Text.Json.JsonSerializer.Serialize(writer, entry.Value, StaticWebAssetNode);
SourceGenerationContext.IDictionaryStringStaticWebAssetNode.g.cs (1)
60global::System.Text.Json.JsonSerializer.Serialize(writer, entry.Value, StaticWebAssetNode);
SourceGenerationContext.StaticWebAssetManifest.g.cs (1)
115global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Microsoft.AspNetCore.StaticWebAssets.ManifestStaticWebAssetFileProvider.StaticWebAssetManifest)value).Root, StaticWebAssetNode);
src\Shared\StaticWebAssets\ManifestStaticWebAssetFileProvider.cs (2)
319return JsonSerializer.Deserialize( 379var parsed = JsonSerializer.Deserialize(ref reader, SourceGenerationContext.DefaultWithConverter.IDictionaryStringStaticWebAssetNode)!;
Microsoft.AspNetCore.Http.Abstractions.Tests (12)
HttpValidationProblemDetailsJsonConverterTest.cs (4)
30JsonSerializer.Serialize(writer, problemDetails, JsonSerializerOptions); 63var problemDetails = JsonSerializer.Deserialize<HttpValidationProblemDetails>(ref reader, JsonSerializerOptions); 106var problemDetails = JsonSerializer.Deserialize<HttpValidationProblemDetails>(ref reader, JsonSerializerOptions); 145var problemDetails = JsonSerializer.Deserialize<HttpValidationProblemDetails>(json, JsonSerializerOptions);
ProblemDetailsJsonConverterTest.cs (8)
26JsonSerializer.Deserialize(ref reader, typeof(ProblemDetails), JsonSerializerOptions); 46var problemDetails = JsonSerializer.Deserialize<ProblemDetails>(ref reader, JsonSerializerOptions); 77var problemDetails = JsonSerializer.Deserialize<ProblemDetails>(json, JsonSerializerOptions); 109var problemDetails = JsonSerializer.Deserialize<ProblemDetails>(json, serializerOptions); 141var problemDetails = JsonSerializer.Deserialize<ProblemDetails>(ref reader, JsonSerializerOptions); 181JsonSerializer.Serialize(writer, value, JsonSerializerOptions); 205JsonSerializer.Serialize(writer, value, JsonSerializerOptions); 236JsonSerializer.Serialize(writer, value, JsonSerializerOptions);
Microsoft.AspNetCore.Http.Extensions (26)
HttpRequestJsonExtensions.cs (15)
84deserializeTask = JsonSerializer.DeserializeAsync<TValue>(request.Body, options, cancellationToken); 88deserializeTask = JsonSerializer.DeserializeAsync<TValue>(request.BodyReader, options, cancellationToken); 94deserializeTask = JsonSerializer.DeserializeAsync<TValue>(inputStream, options, cancellationToken); 140deserializeTask = JsonSerializer.DeserializeAsync(request.Body, jsonTypeInfo, cancellationToken); 144deserializeTask = JsonSerializer.DeserializeAsync(request.BodyReader, jsonTypeInfo, cancellationToken); 150deserializeTask = JsonSerializer.DeserializeAsync(inputStream, jsonTypeInfo, cancellationToken); 196deserializeTask = JsonSerializer.DeserializeAsync(request.Body, jsonTypeInfo, cancellationToken); 200deserializeTask = JsonSerializer.DeserializeAsync(request.BodyReader, jsonTypeInfo, cancellationToken); 206deserializeTask = JsonSerializer.DeserializeAsync(inputStream, jsonTypeInfo, cancellationToken); 276deserializeTask = JsonSerializer.DeserializeAsync(request.Body, type, options, cancellationToken); 280deserializeTask = JsonSerializer.DeserializeAsync(request.BodyReader, type, options, cancellationToken); 286deserializeTask = JsonSerializer.DeserializeAsync(inputStream, type, options, cancellationToken); 336deserializeTask = JsonSerializer.DeserializeAsync(request.Body, type, context, cancellationToken); 340deserializeTask = JsonSerializer.DeserializeAsync(request.BodyReader, type, context, cancellationToken); 346deserializeTask = JsonSerializer.DeserializeAsync(inputStream, type, context, cancellationToken);
HttpResponseJsonExtensions.cs (10)
99return JsonSerializer.SerializeAsync(response.BodyWriter, value, options, cancellationToken); 130return JsonSerializer.SerializeAsync(response.BodyWriter, value, jsonTypeInfo, cancellationToken); 137await JsonSerializer.SerializeAsync(response.BodyWriter, value, jsonTypeInfo, cancellationToken); 172return JsonSerializer.SerializeAsync(response.BodyWriter, value, jsonTypeInfo, cancellationToken); 179await JsonSerializer.SerializeAsync(response.BodyWriter, value, jsonTypeInfo, cancellationToken); 195await JsonSerializer.SerializeAsync(body, value, options, cancellationToken); 279return JsonSerializer.SerializeAsync(response.BodyWriter, value, type, options, cancellationToken); 293await JsonSerializer.SerializeAsync(body, value, type, options, cancellationToken); 329return JsonSerializer.SerializeAsync(response.BodyWriter, value, type, context, cancellationToken); 336await JsonSerializer.SerializeAsync(body, value, type, context, cancellationToken);
JsonOptions.cs (1)
27TypeInfoResolver = JsonSerializer.IsReflectionEnabledByDefault ? CreateDefaultTypeResolver() : JsonTypeInfoResolver.Combine()
Microsoft.AspNetCore.Http.Microbenchmarks (3)
src\Http\Http.Extensions\test\RequestDelegateGenerator\RequestDelegateCreationTestBase.cs (2)
225var requestBodyBytes = JsonSerializer.SerializeToUtf8Bytes(requestData); 243var deserializedObject = JsonSerializer.Deserialize<T>(body, new JsonSerializerOptions()
src\Http\Http.Extensions\test\RequestDelegateGenerator\SharedTypes.cs (1)
92var body = await JsonSerializer.DeserializeAsync<JsonTodo>(context.Request.Body);
Microsoft.AspNetCore.Http.Results (1)
ServerSentEventsResult.cs (1)
90var json = JsonSerializer.SerializeToUtf8Bytes(item.Data, typeInfo);
Microsoft.AspNetCore.Http.Results.Tests (19)
HttpResultsHelperTests.cs (6)
40var body = JsonSerializer.Deserialize<TodoStruct>(responseBodyStream.ToArray(), serializerOptions); 71var body = JsonSerializer.Deserialize<Todo>(responseBodyStream.ToArray(), serializerOptions); 104var body = JsonSerializer.Deserialize<TodoChild>(responseBodyStream.ToArray(), serializerOptions); 138var body = JsonSerializer.Deserialize<TodoChild>(responseBodyStream.ToArray(), serializerOptions); 172var body = JsonSerializer.Deserialize<TodoJsonChild>(responseBodyStream.ToArray(), serializerOptions); 200var body = JsonSerializer.Deserialize<JsonTodo[]>(responseBodyStream.ToArray(), serializerOptions);
JsonResultTests.cs (5)
108var responseDetails = JsonSerializer.Deserialize<Todo>(stream); 114Assert.Equal(JsonSerializer.Serialize(value, options: jsonOptions), Encoding.UTF8.GetString(stream.ToArray())); 140var responseDetails = JsonSerializer.Deserialize<ProblemDetails>(stream, JsonSerializerOptions.Web); 169var responseDetails = JsonSerializer.Deserialize<HttpValidationProblemDetails>(stream, JsonSerializerOptions.Web); 201var responseDetails = JsonSerializer.Deserialize<HttpValidationProblemDetails>(stream, JsonSerializerOptions.Web);
ProblemResultTests.cs (5)
38var responseDetails = JsonSerializer.Deserialize<ProblemDetails>(stream, JsonSerializerOptions.Web); 70var responseDetails = JsonSerializer.Deserialize<ProblemDetails>(stream, JsonSerializerOptions.Web); 99var responseDetails = JsonSerializer.Deserialize<HttpValidationProblemDetails>(stream, JsonSerializerOptions.Web); 131var responseDetails = JsonSerializer.Deserialize<HttpValidationProblemDetails>(stream, JsonSerializerOptions.Web); 163var responseDetails = JsonSerializer.Deserialize<HttpValidationProblemDetails>(stream, JsonSerializerOptions.Web);
TestJsonContext.JsonTodoArray.g.cs (1)
59global::System.Text.Json.JsonSerializer.Serialize(writer, value[i], JsonTodo);
ValidationProblemResultTests.cs (2)
42var responseDetails = JsonSerializer.Deserialize<ProblemDetails>(stream, JsonSerializerOptions.Web); 74var responseDetails = JsonSerializer.Deserialize<ProblemDetails>(stream, JsonSerializerOptions.Web);
Microsoft.AspNetCore.Identity (33)
IdentityEndpointsJsonSerializerContext.TwoFactorRequest.g.cs (1)
167global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Microsoft.AspNetCore.Identity.Data.TwoFactorRequest)value).Enable, NullableBoolean);
IdentityJsonSerializerContext.AuthenticatorAssertionResponse.g.cs (4)
159global::System.Text.Json.JsonSerializer.Serialize(writer, __value_AuthenticatorData, BufferSource); 165global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Signature, BufferSource); 171global::System.Text.Json.JsonSerializer.Serialize(writer, __value_UserHandle, BufferSource); 177global::System.Text.Json.JsonSerializer.Serialize(writer, __value_ClientDataJSON, BufferSource);
IdentityJsonSerializerContext.AuthenticatorAttestationResponse.g.cs (2)
136global::System.Text.Json.JsonSerializer.Serialize(writer, __value_AttestationObject, BufferSource); 148global::System.Text.Json.JsonSerializer.Serialize(writer, __value_ClientDataJSON, BufferSource);
IdentityJsonSerializerContext.CollectedClientData.g.cs (2)
204global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Challenge, BufferSource); 215global::System.Text.Json.JsonSerializer.Serialize(writer, __value_CrossOrigin, NullableBoolean);
IdentityJsonSerializerContext.PasskeyAssertionState.g.cs (1)
108global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Microsoft.AspNetCore.Identity.PasskeyAssertionState)value).Challenge, ReadOnlyMemoryByte);
IdentityJsonSerializerContext.PasskeyAttestationState.g.cs (1)
111global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Microsoft.AspNetCore.Identity.PasskeyAttestationState)value).Challenge, ReadOnlyMemoryByte);
IdentityJsonSerializerContext.PublicKeyCredentialAuthenticatorAssertionResponse.g.cs (2)
180global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Id, BufferSource); 188global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Microsoft.AspNetCore.Identity.PublicKeyCredential<global::Microsoft.AspNetCore.Identity.AuthenticatorAssertionResponse>)value).ClientExtensionResults, JsonElement);
IdentityJsonSerializerContext.PublicKeyCredentialAuthenticatorAttestationResponse.g.cs (2)
180global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Id, BufferSource); 188global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Microsoft.AspNetCore.Identity.PublicKeyCredential<global::Microsoft.AspNetCore.Identity.AuthenticatorAttestationResponse>)value).ClientExtensionResults, JsonElement);
IdentityJsonSerializerContext.PublicKeyCredentialCreationOptions.g.cs (3)
319global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Challenge, BufferSource); 331global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Timeout, NullableUInt64); 366global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Extensions, NullableJsonElement);
IdentityJsonSerializerContext.PublicKeyCredentialDescriptor.g.cs (1)
143global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Id, BufferSource);
IdentityJsonSerializerContext.PublicKeyCredentialParameters.g.cs (1)
110global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Microsoft.AspNetCore.Identity.PublicKeyCredentialParameters)value).Alg, COSEAlgorithmIdentifier);
IdentityJsonSerializerContext.PublicKeyCredentialRequestOptions.g.cs (3)
217global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Challenge, BufferSource); 223global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Timeout, NullableUInt64); 251global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Extensions, NullableJsonElement);
IdentityJsonSerializerContext.PublicKeyCredentialUserEntity.g.cs (1)
139global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Id, BufferSource);
PasskeyHandler.cs (9)
79var optionsJson = JsonSerializer.Serialize(options, IdentityJsonSerializerContext.Default.PublicKeyCredentialCreationOptions); 80var attestationStateJson = JsonSerializer.Serialize(attestationState, IdentityJsonSerializerContext.Default.PasskeyAttestationState); 131var optionsJson = JsonSerializer.Serialize(options, IdentityJsonSerializerContext.Default.PublicKeyCredentialRequestOptions); 132var assertionStateJson = JsonSerializer.Serialize(assertionState, IdentityJsonSerializerContext.Default.PasskeyAssertionState); 224credential = JsonSerializer.Deserialize(context.CredentialJson, IdentityJsonSerializerContext.Default.PublicKeyCredentialAuthenticatorAttestationResponse) 239attestationState = JsonSerializer.Deserialize(attestationStateJson, IdentityJsonSerializerContext.Default.PasskeyAttestationState) 379credential = JsonSerializer.Deserialize(context.CredentialJson, IdentityJsonSerializerContext.Default.PublicKeyCredentialAuthenticatorAssertionResponse) 394assertionState = JsonSerializer.Deserialize(assertionStateJson, IdentityJsonSerializerContext.Default.PasskeyAssertionState) 575clientData = JsonSerializer.Deserialize(utf8Json.Span, IdentityJsonSerializerContext.Default.CollectedClientData)
Microsoft.AspNetCore.Identity.Test (3)
Passkeys\PasskeyHandlerAssertionTest.cs (1)
1056var requestOptions = JsonSerializer.Deserialize(
Passkeys\PasskeyHandlerAttestationTest.cs (1)
1035var creationOptions = JsonSerializer.Deserialize(
Passkeys\PasskeyScenarioTest.cs (1)
93_jsonElementValue = JsonSerializer.Deserialize<JsonElement>(rawValue, _jsonSerializerOptions);
Microsoft.AspNetCore.Identity.UI (2)
Areas\Identity\Pages\V4\Account\Manage\DownloadPersonalData.cshtml.cs (1)
78return new FileContentResult(JsonSerializer.SerializeToUtf8Bytes(personalData), "application/json");
Areas\Identity\Pages\V5\Account\Manage\DownloadPersonalData.cshtml.cs (1)
78return new FileContentResult(JsonSerializer.SerializeToUtf8Bytes(personalData), "application/json");
Microsoft.AspNetCore.JsonPatch.SystemTextJson (6)
Helpers\JsonUtilities.cs (1)
44var docA = JsonSerializer.SerializeToDocument(item, serializerOptions);
Internal\ConversionResultProvider.cs (3)
79return JsonSerializer.Deserialize(jsonElement, targetType, serializerOptions); 82using JsonDocument doc = JsonSerializer.SerializeToDocument(value, serializerOptions); 83return JsonSerializer.Deserialize(doc.RootElement, targetType, serializerOptions);
Internal\JsonObjectAdapter.cs (2)
22obj[segment] = value != null ? JsonSerializer.SerializeToNode(value, serializerOptions) : GetJsonNull(); 83obj[index] = value != null ? JsonSerializer.SerializeToNode(value, serializerOptions) : GetJsonNull();
Microsoft.AspNetCore.JsonPatch.SystemTextJson.Tests (19)
IntegrationTests\HeterogenousCollectionTests.cs (4)
96return JsonSerializer.Deserialize<Circle>(root.GetRawText(), options); 100return JsonSerializer.Deserialize<Rectangle>(root.GetRawText(), options); 112JsonSerializer.Serialize(writer, circle, options); 116JsonSerializer.Serialize(writer, rectangle, options);
IntegrationTests\NestedObjectIntegrationTest.cs (2)
50var serialized = JsonSerializer.Serialize(patchDocument); 51var deserialized = JsonSerializer.Deserialize<JsonPatchDocument<SimpleObjectWithNestedObject>>(serialized);
JsonPatchDocumentJObjectTest.cs (2)
18var model = new ObjectWithJObject { CustomData = (JsonObject)JsonSerializer.SerializeToNode(new { Emails = new[] { "foo@bar.com" } }) }; 34var model = new ObjectWithJObject { CustomData = (JsonObject)JsonSerializer.SerializeToNode(new { Email = "foo@bar.com", Name = "Bar" }) };
JsonPatchDocumentTest.cs (11)
65var serialized = JsonSerializer.Serialize(patchDocument); 66var deserialized = JsonSerializer.Deserialize<JsonPatchDocument<SimpleObject>>(serialized); 126var serializedTyped = JsonSerializer.Serialize(patchDocTyped); 127var serializedUntyped = JsonSerializer.Serialize(patchDocUntyped); 128var deserialized = JsonSerializer.Deserialize<JsonPatchDocument>(serializedTyped); 158var serialized = JsonSerializer.Serialize(patchDocument); 161var deserialized = JsonSerializer.Deserialize<JsonPatchDocument<SimpleObject>>(serialized); 177= JsonSerializer.Deserialize<JsonPatchDocument>(serialized); 196= JsonSerializer.Deserialize<JsonPatchDocument<SimpleObject>>(serialized, options); 241var docSuccess = JsonSerializer.Deserialize<JsonPatchDocument<SimpleObject>>(json, compatibleSerializerOption); 256return JsonSerializer.Serialize<JsonPatchDocument<SimpleObject>>(document, jsonSerializerOptions);
Microsoft.AspNetCore.Mvc.Core (15)
Formatters\SystemTextJsonInputFormatter.cs (5)
11/// A <see cref="TextInputFormatter"/> for JSON content that uses <see cref="JsonSerializer"/>. 46/// Gets the <see cref="JsonSerializerOptions"/> used to configure the <see cref="JsonSerializer"/>. 75model = await JsonSerializer.DeserializeAsync(httpContext.Request.Body, context.ModelType, SerializerOptions); 79model = await JsonSerializer.DeserializeAsync(httpContext.Request.BodyReader, context.ModelType, SerializerOptions); 85model = await JsonSerializer.DeserializeAsync(inputStream, context.ModelType, SerializerOptions);
Formatters\SystemTextJsonOutputFormatter.cs (6)
14/// A <see cref="TextOutputFormatter"/> for JSON content that uses <see cref="JsonSerializer"/>. 52/// Gets the <see cref="JsonSerializerOptions"/> used to configure the <see cref="JsonSerializer"/>. 94await JsonSerializer.SerializeAsync(responseWriter, context.Object, jsonTypeInfo, httpContext.RequestAborted); 98await JsonSerializer.SerializeAsync(responseWriter, context.Object, SerializerOptions, httpContext.RequestAborted); 114await JsonSerializer.SerializeAsync(transcodingStream, context.Object, jsonTypeInfo); 118await JsonSerializer.SerializeAsync(transcodingStream, context.Object, SerializerOptions);
FromBodyAttribute.cs (1)
16/// In the case of ASP.NET Core Minimal APIs, the body is deserialized by <see cref="System.Text.Json.JsonSerializer"/>.
Infrastructure\SystemTextJsonResultExecutor.cs (2)
69await JsonSerializer.SerializeAsync(responseWriter, value, objectType, jsonSerializerOptions, context.HttpContext.RequestAborted); 82await JsonSerializer.SerializeAsync(transcodingStream, value, objectType, jsonSerializerOptions, context.HttpContext.RequestAborted);
JsonOptions.cs (1)
45TypeInfoResolver = JsonSerializer.IsReflectionEnabledByDefault ? CreateDefaultTypeResolver() : JsonTypeInfoResolver.Combine()
Microsoft.AspNetCore.Mvc.Core.Test (20)
Formatters\SystemTextJsonOutputFormatterTest.cs (2)
91await JsonSerializer.SerializeAsync(expected, LargeAsync(), JsonSerializerOptions.Web); 287if (JsonSerializer.IsReflectionEnabledByDefault)
Infrastructure\DefaultApiProblemDetailsWriterTest.cs (3)
45var problemDetails = await JsonSerializer.DeserializeAsync<ProblemDetails>(stream, JsonSerializerOptions.Web); 84var problemDetails = await JsonSerializer.DeserializeAsync<ProblemDetails>(stream, JsonSerializerOptions.Web); 115var problemDetails = await JsonSerializer.DeserializeAsync<ProblemDetails>(stream);
Infrastructure\JsonResultExecutorTestBase.cs (10)
26var expected = Encoding.UTF8.GetBytes(JsonSerializer.Serialize(new { foo = "abcd" })); 46var expected = Encoding.UTF8.GetBytes(JsonSerializer.Serialize(new { foo = "abcd" })); 67var expected = Encoding.Unicode.GetBytes(JsonSerializer.Serialize(new { foo = "abcd" })); 91var expected = Encoding.Unicode.GetBytes(JsonSerializer.Serialize(new { foo = "abcd" })); 111var expected = Encoding.UTF8.GetBytes(JsonSerializer.Serialize(new { foo = "abcd" })); 135var expected = Encoding.UTF8.GetBytes(JsonSerializer.Serialize(new { foo = "abcd" })); 161var expected = Encoding.UTF8.GetBytes(JsonSerializer.Serialize(new { foo = "abcd" })); 182var expected = Encoding.UTF8.GetBytes(JsonSerializer.Serialize( 331var expected = JsonSerializer.Serialize(new[] { "Hello", "world" }); 349var expected = Encoding.UTF8.GetBytes(JsonSerializer.Serialize(new[] { 1, 2 }));
Infrastructure\ValidationProblemDetailsJsonConverterTest.cs (5)
30var problemDetails = JsonSerializer.Deserialize<ValidationProblemDetails>(ref reader, JsonSerializerOptions); 72var problemDetails = JsonSerializer.Deserialize<ValidationProblemDetails>(ref reader, JsonSerializerOptions); 110var problemDetails = JsonSerializer.Deserialize<ValidationProblemDetails>(json, JsonSerializerOptions); 149JsonSerializer.Serialize(writer, problemDetails, JsonSerializerOptions); 182JsonSerializer.Serialize(writer, problemDetails, options);
Microsoft.AspNetCore.Mvc.FunctionalTests (8)
AsyncEnumerableTestBase.cs (1)
50var projects = JsonSerializer.Deserialize<List<Project>>(content, TestJsonSerializerOptionsProvider.Options);
BasicTests.cs (7)
437var result = JsonSerializer.Deserialize<Product>(response, TestJsonSerializerOptionsProvider.Options); 451var result = JsonSerializer.Deserialize<Product[]>(response, TestJsonSerializerOptionsProvider.Options); 470var assemblyParts = JsonSerializer.Deserialize<IList<string>>(response, TestJsonSerializerOptionsProvider.Options); 541var data = JsonSerializer.Deserialize<BindPropertyControllerData>(content, TestJsonSerializerOptionsProvider.Options); 564var data = JsonSerializer.Deserialize<BindPropertyControllerData>(content, TestJsonSerializerOptionsProvider.Options); 586var data = JsonSerializer.Deserialize<BindPropertyControllerData>(content, TestJsonSerializerOptionsProvider.Options); 656var problemDetails = JsonSerializer.Deserialize<ValidationProblemDetails>(content, TestJsonSerializerOptionsProvider.Options);
Microsoft.AspNetCore.Mvc.NewtonsoftJson.Test (11)
NewtonsoftJsonResultExecutorTest.cs (1)
35var expected = System.Text.Json.JsonSerializer.Serialize(new[] { "Hello", "world" });
src\Mvc\Mvc.Core\test\Infrastructure\JsonResultExecutorTestBase.cs (10)
26var expected = Encoding.UTF8.GetBytes(JsonSerializer.Serialize(new { foo = "abcd" })); 46var expected = Encoding.UTF8.GetBytes(JsonSerializer.Serialize(new { foo = "abcd" })); 67var expected = Encoding.Unicode.GetBytes(JsonSerializer.Serialize(new { foo = "abcd" })); 91var expected = Encoding.Unicode.GetBytes(JsonSerializer.Serialize(new { foo = "abcd" })); 111var expected = Encoding.UTF8.GetBytes(JsonSerializer.Serialize(new { foo = "abcd" })); 135var expected = Encoding.UTF8.GetBytes(JsonSerializer.Serialize(new { foo = "abcd" })); 161var expected = Encoding.UTF8.GetBytes(JsonSerializer.Serialize(new { foo = "abcd" })); 182var expected = Encoding.UTF8.GetBytes(JsonSerializer.Serialize( 331var expected = JsonSerializer.Serialize(new[] { "Hello", "world" }); 349var expected = Encoding.UTF8.GetBytes(JsonSerializer.Serialize(new[] { 1, 2 }));
Microsoft.AspNetCore.Mvc.TagHelpers.Test (2)
ProtectedPrerenderComponentApplicationStateTest.cs (2)
45var persistedState = Convert.ToBase64String(_protector.Protect(JsonSerializer.SerializeToUtf8Bytes(expectedState))); 66var persistedState = Convert.ToBase64String(JsonSerializer.SerializeToUtf8Bytes(expectedState));
Microsoft.AspNetCore.Mvc.Testing (1)
WebApplicationFactory.cs (1)
392var data = JsonSerializer.Deserialize(File.ReadAllBytes(file), CustomJsonSerializerContext.Default.IDictionaryStringString)!;
Microsoft.AspNetCore.Mvc.ViewFeatures (1)
Rendering\SystemTextJsonHelper.cs (1)
25var json = JsonSerializer.Serialize(value, _htmlSafeJsonSerializerOptions);
Microsoft.AspNetCore.OpenApi (4)
Extensions\JsonNodeSchemaExtensions.cs (1)
189schema[schemaAttribute] = JsonSerializer.SerializeToNode(defaultValue, jsonTypeInfo);
Schemas\OpenApiJsonSchema.Helpers.cs (2)
35values.Add((T)JsonSerializer.Deserialize(ref reader, typeof(T), OpenApiJsonSchemaContext.Default)!); 80values[key] = (T)JsonSerializer.Deserialize(ref reader, typeof(T), OpenApiJsonSchemaContext.Default)!;
Services\Schemas\OpenApiSchemaService.cs (1)
238var deserializedSchema = JsonSerializer.Deserialize(schemaAsJsonObject, _jsonSchemaContext.OpenApiJsonSchema);
Microsoft.AspNetCore.OpenApi.Build.Tests (1)
GenerateAdditionalXmlFilesForOpenApiTests.cs (1)
33var result = JsonSerializer.Deserialize<ItemsResult>(output);
Microsoft.AspNetCore.Routing.FunctionalTests (5)
MinimalFormTests.cs (5)
67var result = JsonSerializer.Deserialize<Todo>(body, JsonSerializerOptions.Web); 127var result = JsonSerializer.Deserialize<Todo>(body, JsonSerializerOptions.Web); 288var result = JsonSerializer.Deserialize<Todo>(body, JsonSerializerOptions.Web); 335var result = JsonSerializer.Deserialize<Todo>(body, JsonSerializerOptions.Web); 495var result = JsonSerializer.Deserialize<Todo>(body, JsonSerializerOptions.Web);
Microsoft.AspNetCore.SignalR.Protocols.Json (2)
Protocol\JsonHubProtocol.cs (2)
917private void SerializeObject(Utf8JsonWriter writer, object? value) => JsonSerializer.Serialize(writer, value, _payloadSerializerOptions); 921private object? DeserializeObject(ref Utf8JsonReader reader, Type type) => JsonSerializer.Deserialize(ref reader, type, _payloadSerializerOptions);
Microsoft.AspNetCore.StaticAssets (1)
StaticAssetsManifest.cs (1)
32var result = JsonSerializer.Deserialize(content, StaticAssetsManifestJsonContext.Default.StaticAssetsManifest) ??
Microsoft.AspNetCore.StaticAssets.Tests (1)
StaticAssetsIntegrationTests.cs (1)
662JsonSerializer.Serialize(writer, manifest);
Microsoft.CodeAnalysis.CSharp.EditorFeatures (2)
StringCopyPaste\StringCopyPasteData.cs (2)
32return JsonSerializer.Serialize(this, typeof(StringCopyPasteData)); 48var value = JsonSerializer.Deserialize(JsonDocument.Parse(json), typeof(StringCopyPasteData));
Microsoft.CodeAnalysis.CSharp.EditorFeatures.UnitTests (1)
Rename\CSharpInlineRenameServiceTests.cs (1)
73var expectedContext = JsonSerializer.Deserialize<ImmutableDictionary<string, ImmutableArray<(string, string)>>>(expectedContextJson, serializationOptions);
Microsoft.CodeAnalysis.ExternalAccess.Razor.Features (4)
Cohost\RazorSemanticTokensRefreshQueueWrapper.cs (1)
34var clientCapabilities = JsonSerializer.Deserialize<VSInternalClientCapabilities>(clientCapabilitiesString) ?? new();
Cohost\RazorStartupServiceFactory.cs (1)
92var serializedClientCapabilities = JsonSerializer.Serialize(clientCapabilities, ProtocolConversions.LspJsonSerializerOptions);
Testing\RazorTestCapabilitiesProvider.cs (2)
31var clientCapabilitiesJson = JsonSerializer.Serialize(clientCapabilities, JsonSerializerOptions); 33var serverCapabilities = JsonSerializer.Deserialize<VSInternalServerCapabilities>(serverCapabilitiesJson, JsonSerializerOptions);
Microsoft.CodeAnalysis.ExternalAccess.Xaml (2)
External\ResolveDataConversions.cs (2)
24var resolveData = JsonSerializer.Deserialize<DataResolveData>((JsonElement)requestData); 40resolveData = JsonSerializer.Deserialize<DataIdResolveData>(token);
Microsoft.CodeAnalysis.Features (3)
Extensions\ExtensionMessageHandlerService.cs (2)
238var message = JsonSerializer.Deserialize(jsonMessage, handler.MessageType); 240return new(JsonSerializer.Serialize(result, handler.ResponseType), ExtensionWasUnloaded: false, ExtensionException: null);
Intents\IntentDataProvider.cs (1)
33return JsonSerializer.Deserialize<T>(_serializedIntentData, s_serializerOptions.Value);
Microsoft.CodeAnalysis.LanguageServer (3)
FileBasedPrograms\VirtualProjectXmlProvider.cs (2)
41var inputJson = JsonSerializer.Serialize(input, RunFileApiJsonSerializerContext.Default.RunApiInput); 67var response = JsonSerializer.Deserialize(responseJson, RunFileApiJsonSerializerContext.Default.RunApiOutput);
Program.cs (1)
140Console.WriteLine(JsonSerializer.Serialize(new NamedPipeInformation(clientPipeName)));
Microsoft.CodeAnalysis.LanguageServer.Protocol (43)
Handler\CodeActions\CodeActionFixAllResolveHandler.cs (1)
69var resolveData = JsonSerializer.Deserialize<CodeActionResolveData>((JsonElement)request.Data!, ProtocolConversions.LspJsonSerializerOptions);
Handler\CodeActions\CodeActionResolveHandler.cs (1)
100var resolveData = JsonSerializer.Deserialize<CodeActionResolveData>((JsonElement)request.Data!, ProtocolConversions.LspJsonSerializerOptions);
Handler\CodeLens\CodeLensResolveHandler.cs (1)
95var resolveData = JsonSerializer.Deserialize<CodeLensResolveData>((JsonElement)codeLens.Data, ProtocolConversions.LspJsonSerializerOptions);
Handler\Completion\CompletionResolveHandler.cs (1)
128var resolveData = JsonSerializer.Deserialize<DocumentResolveData>((JsonElement)request.Data);
Handler\Completion\Extensions.cs (1)
54var resolveData = JsonSerializer.Deserialize<CompletionResolveData>((JsonElement)request.Data, ProtocolConversions.LspJsonSerializerOptions);
Handler\InlayHint\InlayHintResolveHandler.cs (1)
85var resolveData = JsonSerializer.Deserialize<InlayHintResolveData>((JsonElement)inlayHint.Data, ProtocolConversions.LspJsonSerializerOptions);
Handler\ServerLifetime\InitializeHandler.cs (1)
34m["capabilities"] = JsonSerializer.Serialize(serverCapabilities, ProtocolConversions.LspJsonSerializerOptions);
Protocol\Converters\FormattingOptionsConverter.cs (1)
141JsonSerializer.Serialize(writer, item.Value, options);
Protocol\Converters\InitializeParamsWorkspaceFoldersConverter.cs (2)
31return JsonSerializer.Deserialize<WorkspaceFolder[]>(ref reader, options) ?? []; 36JsonSerializer.Serialize(writer, value, options);
Protocol\Converters\NaturalObjectConverter.cs (2)
28JsonSerializer.Serialize(writer, value, runtimeType, options); 67return JsonSerializer.Deserialize<JsonElement>(ref reader);
Protocol\Converters\ParameterInformationConverter.cs (2)
47JsonSerializer.Serialize(writer, value.Label, options); 52JsonSerializer.Serialize(writer, value.Documentation, options);
Protocol\Converters\SumConverter.cs (2)
142private static readonly MethodInfo jsonSerializerDeserializeMethod = typeof(JsonSerializer) 279JsonSerializer.Serialize(writer, sumValue, options);
Protocol\Converters\TextDocumentSyncConverter.cs (3)
35return JsonSerializer.Deserialize<TextDocumentSyncOptions>(value); 39return JsonSerializer.Deserialize<TextDocumentSyncOptions>(ref reader, options); 48JsonSerializer.Serialize(writer, value, options);
Protocol\Extensions\Converters\VSExtensionConverter.cs (3)
25return JsonSerializer.Deserialize<TExtension>(ref reader, options); 34JsonSerializer.Serialize(writer, extension, options); 40JsonSerializer.Serialize(writer, (object)value!, DropConverter(options));
Protocol\Internal\Converters\ObjectContentConverter.cs (1)
78return JsonSerializer.Deserialize(ref reader, objectType, options);
Protocol\Internal\Efficiency\OptimizedVSCompletionListJsonConverter.cs (16)
45JsonSerializer.Serialize(writer, completionList.ContinueCharacters, options); 51JsonSerializer.Serialize(writer, completionList.Data, options); 57JsonSerializer.Serialize(writer, completionList.CommitCharacters, options); 90JsonSerializer.Serialize(writer, completionList.ItemDefaults, options); 106jsonString = JsonSerializer.Serialize(vsCompletionItem.Icon, options); 116JsonSerializer.Serialize(writer, vsCompletionItem.Description, options); 124jsonString = JsonSerializer.Serialize(basicCommitCharacters, options); 136jsonString = JsonSerializer.Serialize(augmentedCommitCharacters, options); 156JsonSerializer.Serialize(writer, completionItem.LabelDetails, options); 169JsonSerializer.Serialize(writer, completionItem.Documentation, options); 201JsonSerializer.Serialize(writer, completionItem.TextEdit, options); 207JsonSerializer.Serialize(writer, completionItem.TextEditText, options); 213JsonSerializer.Serialize(writer, completionItem.AdditionalTextEdits, options); 220jsonString = JsonSerializer.Serialize(completionItem.CommitCharacters, options); 231JsonSerializer.Serialize(writer, completionItem.Command, options); 237JsonSerializer.Serialize(writer, completionItem.Data, options);
RoslynLanguageServer.cs (2)
192var textDocumentIdentifier = JsonSerializer.Deserialize<TextDocumentIdentifier>(textDocumentToken, ProtocolConversions.LspJsonSerializerOptions); 203var data = JsonSerializer.Deserialize<DocumentResolveData>(dataToken, ProtocolConversions.LspJsonSerializerOptions);
src\LanguageServer\Microsoft.CommonLanguageServerProtocol.Framework\SystemTextJsonLanguageServer.cs (2)
49return JsonSerializer.Deserialize<TRequest>(request, _jsonSerializerOptions) 93var serializedResult = JsonSerializer.SerializeToElement(result, target._jsonSerializerOptions);
Microsoft.CodeAnalysis.LanguageServer.Protocol.UnitTests (11)
CodeActions\CodeActionsTests.cs (3)
94r => JsonSerializer.Deserialize<CodeActionResolveData>((JsonElement)r.Data!, ProtocolConversions.LspJsonSerializerOptions)!.UniqueIdentifier == titlePath[1]); 288return JsonSerializer.Deserialize<CodeActionResolveData>((JsonElement)codeAction.Data!, ProtocolConversions.LspJsonSerializerOptions); 313Data = JsonSerializer.SerializeToElement(data, ProtocolConversions.LspJsonSerializerOptions),
CodeActions\RunCodeActionsTests.cs (1)
70JsonSerializer.SerializeToElement(codeActionData, ProtocolConversions.LspJsonSerializerOptions)
CodeLens\CSharpCodeLensTests.cs (1)
438var data = JsonSerializer.Deserialize<CodeLensResolveData>(firstCodeLens.Data!.ToString()!, ProtocolConversions.LspJsonSerializerOptions);
Commands\ExecuteWorkspaceCommandTests.cs (2)
38Arguments = [JsonSerializer.Serialize(new TextDocumentIdentifier { DocumentUri = ProtocolConversions.CreateAbsoluteDocumentUri(@"C:\someFile.cs") })], 67return JsonSerializer.Deserialize<TextDocumentIdentifier>((JsonElement)request.Arguments!.First(), ProtocolConversions.LspJsonSerializerOptions)!;
Diagnostics\DiagnosticRegistrationTests.cs (1)
59.Select(r => JsonSerializer.Deserialize<DiagnosticRegistrationOptions>((JsonElement)r.RegisterOptions!, ProtocolConversions.LspJsonSerializerOptions)!);
InlayHint\CSharpInlayHintTests.cs (1)
126var data = JsonSerializer.Deserialize<InlayHintResolveData>(firstInlayHint.Data!.ToString()!, ProtocolConversions.LspJsonSerializerOptions);
References\FindAllReferencesHandlerTests.cs (1)
507.SelectMany(r => (List<object>)r).Select(r => JsonSerializer.Deserialize<T>((JsonElement)r, ProtocolConversions.LspJsonSerializerOptions))];
UriTests.cs (1)
182var unencodedUri = JsonSerializer.Deserialize<LSP.DidOpenTextDocumentParams>(jsonDocument, JsonSerializerOptions)!.TextDocument.DocumentUri;
Microsoft.CodeAnalysis.LanguageServer.UnitTests (1)
LspFileChangeWatcherTests.cs (1)
111var registration = JsonSerializer.Deserialize<DidChangeWatchedFilesRegistrationOptions>(registrationJson, ProtocolConversions.LspJsonSerializerOptions)!;
Microsoft.CodeAnalysis.Workspaces.MSBuild (3)
Rpc\RpcClient.cs (3)
62response = JsonSerializer.Deserialize<Response>(line, JsonSettings.SingleLineSerializerOptions); 157Parameters = parameters.SelectAsArray(static p => JsonSerializer.SerializeToElement(p, JsonSettings.SingleLineSerializerOptions)) 160var requestJson = JsonSerializer.Serialize(request, JsonSettings.SingleLineSerializerOptions) + Environment.NewLine;
Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost (3)
Rpc\RpcServer.cs (3)
70request = JsonSerializer.Deserialize<Request>(line, JsonSettings.SingleLineSerializerOptions); 158response = new Response { Id = request.Id, Value = result is not null ? JsonSerializer.SerializeToElement(result, JsonSettings.SingleLineSerializerOptions) : null }; 168var responseJson = JsonSerializer.Serialize(response, JsonSettings.SingleLineSerializerOptions);
Microsoft.CodeAnalysis.Workspaces.MSBuild.UnitTests (3)
src\Workspaces\MSBuild\BuildHost\Rpc\RpcServer.cs (3)
70request = JsonSerializer.Deserialize<Request>(line, JsonSettings.SingleLineSerializerOptions); 158response = new Response { Id = request.Id, Value = result is not null ? JsonSerializer.SerializeToElement(result, JsonSettings.SingleLineSerializerOptions) : null }; 168var responseJson = JsonSerializer.Serialize(response, JsonSettings.SingleLineSerializerOptions);
Microsoft.CodeAnalysis.Workspaces.UnitTests (1)
UtilityTest\ExceptionHelpersTests.cs (1)
66Assert.NotNull(JsonSerializer.Serialize(e));
Microsoft.CommonLanguageServerProtocol.Framework.Package (2)
SystemTextJsonLanguageServer.cs (2)
49return JsonSerializer.Deserialize<TRequest>(request, _jsonSerializerOptions) 93var serializedResult = JsonSerializer.SerializeToElement(result, target._jsonSerializerOptions);
Microsoft.DotNet.Build.Tasks.Feed (2)
src\ProductionChannelValidator.cs (2)
402var buildResponse = JsonSerializer.Deserialize<AzureDevOpsBuildInfoResponse>(content, new JsonSerializerOptions 463var classification = JsonSerializer.Deserialize<BranchClassificationResponse>(content, new JsonSerializerOptions
Microsoft.DotNet.Build.Tasks.Workloads (2)
Msi\MsiProperties.wix.cs (1)
116File.WriteAllText(msiJsonPath, JsonSerializer.Serialize(properties));
Msi\WorkloadManifestMsi.wix.cs (1)
79string jsonAsString = JsonSerializer.Serialize(WorkloadPackGroups, typeof(IList<WorkloadPackGroupJson>), new JsonSerializerOptions() { WriteIndented = true });
Microsoft.DotNet.Internal.SymbolHelper (1)
SymbolPromotionHelper.cs (1)
218return await JsonSerializer.DeserializeAsync<SymbolRequestStatus>(result, s_options, cancellationToken: ct);
Microsoft.DotNet.XliffTasks (2)
Model\JsonDocument.cs (2)
26_json = JsonSerializer.Deserialize<Dictionary<string, string>>(text); 31writer.Write(JsonSerializer.Serialize(_json, typeof(Dictionary<string, string>), s_serializerOptions));
Microsoft.Extensions.AI (15)
ChatCompletion\ChatClientStructuredOutputExtensions.cs (1)
162schema = JsonSerializer.SerializeToElement(new JsonObject
ChatCompletion\ChatResponse{T}.cs (1)
102return JsonSerializer.Deserialize(ref reader, typeInfo);
ChatCompletion\DistributedCachingChatClient.cs (4)
79return (ChatResponse?)JsonSerializer.Deserialize(existingJson, JsonSerializerOptions.GetTypeInfo(typeof(ChatResponse))); 93return (IReadOnlyList<ChatResponseUpdate>?)JsonSerializer.Deserialize(existingJson, JsonSerializerOptions.GetTypeInfo(typeof(IReadOnlyList<ChatResponseUpdate>))); 106var newJson = JsonSerializer.SerializeToUtf8Bytes(value, JsonSerializerOptions.GetTypeInfo(typeof(ChatResponse))); 117var newJson = JsonSerializer.SerializeToUtf8Bytes(value, JsonSerializerOptions.GetTypeInfo(typeof(IReadOnlyList<ChatResponseUpdate>)));
ChatCompletion\OpenTelemetryChatClient.cs (5)
419element = JsonSerializer.SerializeToElement(content, unknownContentTypeInfo); 439return JsonSerializer.Serialize(output, _defaultOptions.GetTypeInfo(typeof(IList<object>))); 587JsonSerializer.Serialize(options.Tools.Select(t => t switch 745JsonSerializer.Serialize(new object[1] { new OtelGenericPart { Content = options!.Instructions } }, _defaultOptions.GetTypeInfo(typeof(IList<object>)))); 892private static readonly JsonElement _emptyObject = JsonSerializer.SerializeToElement(new object(), _defaultOptions.GetTypeInfo(typeof(object)));
Embeddings\DistributedCachingEmbeddingGenerator.cs (2)
83return JsonSerializer.Deserialize(existingJson, (JsonTypeInfo<TEmbedding>)_jsonSerializerOptions.GetTypeInfo(typeof(TEmbedding))); 96var newJson = JsonSerializer.SerializeToUtf8Bytes(value, (JsonTypeInfo<TEmbedding>)_jsonSerializerOptions.GetTypeInfo(typeof(TEmbedding)));
Embeddings\LoggingEmbeddingGenerator.cs (1)
90private string AsJson<T>(T value) => JsonSerializer.Serialize(value, _jsonSerializerOptions.GetTypeInfo(typeof(T)));
TelemetryHelpers.cs (1)
26return JsonSerializer.Serialize(value, typeInfo);
Microsoft.Extensions.AI.Abstractions (21)
Contents\FunctionCallContent.cs (1)
53/// instances of this class with <see cref="JsonSerializer"/>; as such, upon deserialization, this property will be <see langword="null"/>.
Contents\FunctionResultContent.cs (1)
58/// instances of this class with <see cref="JsonSerializer"/>. As such, upon deserialization, this property will be <see langword="null"/>.
Functions\AIFunctionFactory.cs (8)
843JsonElement element => JsonSerializer.Deserialize(element, typeInfo), 844JsonDocument doc => JsonSerializer.Deserialize(doc, typeInfo), 845JsonNode node => JsonSerializer.Deserialize(node, typeInfo), 862return JsonSerializer.Deserialize(text, typeInfo); 870string json = JsonSerializer.Serialize(value, serializerOptions.GetTypeInfo(value.GetType())); 871return JsonSerializer.Deserialize(json, typeInfo); 1064return JsonSerializer.SerializeToElement(result, returnTypeInfo); 1069await JsonSerializer.SerializeAsync(stream, result, returnTypeInfo, cancellationToken).ConfigureAwait(true);
Utilities\AIJsonUtilities.cs (2)
134JsonNode? jsonNode = JsonSerializer.SerializeToNode(value, jti); 136JsonSerializer.Serialize(stream, jsonNode, JsonContextNoIndentation.Default.JsonNode!);
Utilities\AIJsonUtilities.Defaults.cs (2)
22/// <para>For Native AOT or applications disabling <see cref="JsonSerializer.IsReflectionEnabledByDefault"/> this instance includes source generated contracts 65if (JsonSerializer.IsReflectionEnabledByDefault)
Utilities\AIJsonUtilities.Schema.Create.cs (4)
166return JsonSerializer.SerializeToElement(schema, JsonContextNoIndentation.Default.JsonNode); 195return JsonSerializer.SerializeToElement(schema, JsonContextNoIndentation.Default.JsonNode); 237? JsonSerializer.SerializeToNode(defaultValue, serializerOptions.GetTypeInfo(defaultValue.GetType())) 363JsonNode? defaultValueNode = JsonSerializer.SerializeToNode(defaultValue, ctx.TypeInfo);
Utilities\AIJsonUtilities.Schema.Transform.cs (3)
32JsonNode? nodeSchema = JsonSerializer.SerializeToNode(schema, JsonContext.Default.JsonElement); 34return JsonSerializer.SerializeToElement(transformedSchema, JsonContextNoIndentation.Default.JsonNode); 181string defaultValueJson = JsonSerializer.Serialize(defaultSchema, JsonContextNoIndentation.Default.JsonNode!);
Microsoft.Extensions.AI.Abstractions.Tests (176)
AssertExtensions.cs (3)
100JsonSerializer.SerializeToNode(expectedJson, AIJsonUtilities.DefaultOptions), 101JsonSerializer.SerializeToNode(actualJson, AIJsonUtilities.DefaultOptions))) 119=> value is JsonElement e ? e : JsonSerializer.SerializeToElement(value, options);
ChatCompletion\ChatFinishReasonTests.cs (2)
69string? json = JsonSerializer.Serialize(role, TestJsonSerializerContext.Default.ChatFinishReason); 72ChatFinishReason? result = JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.ChatFinishReason);
ChatCompletion\ChatMessageTests.cs (2)
282var chatMessageJson = JsonSerializer.Serialize(chatMessage, TestJsonSerializerContext.Default.Options); 284var deserializedMessage = JsonSerializer.Deserialize<ChatMessage>(chatMessageJson, TestJsonSerializerContext.Default.Options)!;
ChatCompletion\ChatOptionsTests.cs (2)
197string json = JsonSerializer.Serialize(options, TestJsonSerializerContext.Default.ChatOptions); 199ChatOptions? deserialized = JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.ChatOptions);
ChatCompletion\ChatResponseFormatTests.cs (9)
47Assert.Equal("{}", JsonSerializer.Serialize(f.Schema, TestJsonSerializerContext.Default.JsonElement)); 55string json = JsonSerializer.Serialize(ChatResponseFormat.Text, TestJsonSerializerContext.Default.ChatResponseFormat); 58ChatResponseFormat? result = JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.ChatResponseFormat); 65string json = JsonSerializer.Serialize(ChatResponseFormat.Json, TestJsonSerializerContext.Default.ChatResponseFormat); 68ChatResponseFormat? result = JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.ChatResponseFormat); 78string json = JsonSerializer.Serialize( 83ChatResponseFormat? result = JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.ChatResponseFormat); 85Assert.Equal("[1,2,3]", JsonSerializer.Serialize(actual.Schema, TestJsonSerializerContext.Default.JsonElement)); 167JsonSerializer.Serialize(format.Schema, AIJsonUtilities.DefaultOptions.GetTypeInfo(typeof(JsonElement))));
ChatCompletion\ChatResponseTests.cs (2)
98string json = JsonSerializer.Serialize(original, TestJsonSerializerContext.Default.ChatResponse); 100ChatResponse? result = JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.ChatResponse);
ChatCompletion\ChatResponseUpdateTests.cs (2)
135string json = JsonSerializer.Serialize(original, TestJsonSerializerContext.Default.ChatResponseUpdate); 137ChatResponseUpdate? result = JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.ChatResponseUpdate);
ChatCompletion\ChatRoleTests.cs (2)
58string? json = JsonSerializer.Serialize(role, TestJsonSerializerContext.Default.ChatRole); 61ChatRole? result = JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.ChatRole);
ChatCompletion\ChatToolModeTests.cs (8)
58string json = JsonSerializer.Serialize(ChatToolMode.Auto, TestJsonSerializerContext.Default.ChatToolMode); 61ChatToolMode? result = JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.ChatToolMode); 68string json = JsonSerializer.Serialize(ChatToolMode.None, TestJsonSerializerContext.Default.ChatToolMode); 71ChatToolMode? result = JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.ChatToolMode); 78string json = JsonSerializer.Serialize(ChatToolMode.RequireAny, TestJsonSerializerContext.Default.ChatToolMode); 81ChatToolMode? result = JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.ChatToolMode); 88string json = JsonSerializer.Serialize(ChatToolMode.RequireSpecific("myFunc"), TestJsonSerializerContext.Default.ChatToolMode); 91ChatToolMode? result = JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.ChatToolMode);
ChatCompletion\ReasoningOptionsTests.cs (12)
51string json = JsonSerializer.Serialize(options, TestJsonSerializerContext.Default.ReasoningOptions); 52ReasoningOptions? deserialized = JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.ReasoningOptions); 64string json = JsonSerializer.Serialize(options, TestJsonSerializerContext.Default.ReasoningOptions); 65ReasoningOptions? deserialized = JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.ReasoningOptions); 77string json = JsonSerializer.Serialize(options, TestJsonSerializerContext.Default.ReasoningOptions); 78ReasoningOptions? deserialized = JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.ReasoningOptions); 90string json = JsonSerializer.Serialize(options, TestJsonSerializerContext.Default.ReasoningOptions); 91ReasoningOptions? deserialized = JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.ReasoningOptions); 104string json = JsonSerializer.Serialize(effort, TestJsonSerializerContext.Default.ReasoningEffort); 105ReasoningEffort? deserialized = JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.ReasoningEffort); 116string json = JsonSerializer.Serialize(output, TestJsonSerializerContext.Default.ReasoningOutput); 117ReasoningOutput? deserialized = JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.ReasoningOutput);
Contents\AIAnnotationTests.cs (2)
52string json = JsonSerializer.Serialize(original, AIJsonUtilities.DefaultOptions.GetTypeInfo(typeof(AIAnnotation))); 55var deserialized = (AIAnnotation?)JsonSerializer.Deserialize(json, AIJsonUtilities.DefaultOptions.GetTypeInfo(typeof(AIAnnotation)));
Contents\AIContentTests.cs (4)
48string json = JsonSerializer.Serialize(original, AIJsonUtilities.DefaultOptions.GetTypeInfo(typeof(AIContent))); 51AIContent? deserialized = (AIContent?)JsonSerializer.Deserialize(json, AIJsonUtilities.DefaultOptions.GetTypeInfo(typeof(AIContent))); 83var serialized = JsonSerializer.Serialize(message, AIJsonUtilities.DefaultOptions); 84ChatMessage? deserialized = JsonSerializer.Deserialize<ChatMessage>(serialized, AIJsonUtilities.DefaultOptions);
Contents\CitationAnnotationTests.cs (2)
78string json = JsonSerializer.Serialize(original, AIJsonUtilities.DefaultOptions.GetTypeInfo(typeof(CitationAnnotation))); 81var deserialized = (CitationAnnotation?)JsonSerializer.Deserialize(json, AIJsonUtilities.DefaultOptions.GetTypeInfo(typeof(CitationAnnotation)));
Contents\CodeInterpreterToolCallContentTests.cs (2)
81var json = JsonSerializer.Serialize(content, AIJsonUtilities.DefaultOptions); 82var deserializedSut = JsonSerializer.Deserialize<CodeInterpreterToolCallContent>(json, AIJsonUtilities.DefaultOptions);
Contents\CodeInterpreterToolResultContentTests.cs (2)
83var json = JsonSerializer.Serialize(content, AIJsonUtilities.DefaultOptions); 84var deserializedSut = JsonSerializer.Deserialize<CodeInterpreterToolResultContent>(json, AIJsonUtilities.DefaultOptions);
Contents\DataContentTests.cs (9)
146JsonSerializer.Serialize( 152JsonSerializer.Serialize( 158JsonSerializer.Serialize( 168Assert.Throws<ArgumentNullException>("uri", () => JsonSerializer.Deserialize<DataContent>(json, TestJsonSerializerContext.Default.Options)!); 175var content = JsonSerializer.Deserialize<DataContent>("""{"uri":"data:application/octet-stream;base64,AQIDBA=="}""", TestJsonSerializerContext.Default.Options)!; 183content = JsonSerializer.Deserialize<DataContent>("""{"uri":"data:application/octet-stream;base64,AQIDBA=="}""", TestJsonSerializerContext.Default.Options)!; 189content = JsonSerializer.Deserialize<DataContent>(""" 216var content = JsonSerializer.Deserialize<DataContent>(serialized, TestJsonSerializerContext.Default.Options)!; 217var reSerialization = JsonSerializer.Serialize(content, TestJsonSerializerContext.Default.Options);
Contents\ErrorContentTests.cs (2)
57var json = JsonSerializer.Serialize(errorContent, options); 58var deserializedErrorContent = JsonSerializer.Deserialize<ErrorContent>(json, options);
Contents\FunctionApprovalRequestContentTests.cs (2)
84var json = JsonSerializer.Serialize(content, AIJsonUtilities.DefaultOptions); 85var deserializedContent = JsonSerializer.Deserialize<FunctionApprovalRequestContent>(json, AIJsonUtilities.DefaultOptions);
Contents\FunctionApprovalResponseContentTests.cs (2)
48var json = JsonSerializer.Serialize(content, AIJsonUtilities.DefaultOptions); 49var deserializedContent = JsonSerializer.Deserialize<FunctionApprovalResponseContent>(json, AIJsonUtilities.DefaultOptions);
Contents\FunctionCallContentTests.cs (14)
93var json = JsonSerializer.SerializeToNode(sut, TestJsonSerializerContext.Default.Options); 121var deserialized = JsonSerializer.Deserialize<FunctionCallContent>(json, TestJsonSerializerContext.Default.Options); 134var deserialized = JsonSerializer.Deserialize<FunctionCallContent>(json, TestJsonSerializerContext.Default.Options); 149var json = JsonSerializer.SerializeToNode(original, TestJsonSerializerContext.Default.Options); 150var deserialized = JsonSerializer.Deserialize<FunctionCallContent>(json, TestJsonSerializerContext.Default.Options); 167var json = JsonSerializer.SerializeToNode(sut, TestJsonSerializerContext.Default.Options); 168var deserializedSut = JsonSerializer.Deserialize<FunctionCallContent>(json, TestJsonSerializerContext.Default.Options); 202AIFunctionArguments arguments = JsonSerializer.Deserialize<AIFunctionArguments>(""" 236var arguments = JsonSerializer.Deserialize<Dictionary<string, JsonDocument>>(""" 257var arguments = JsonSerializer.Deserialize<Dictionary<string, JsonNode>>(""" 278AIFunctionArguments arguments = new(JsonSerializer.Deserialize<Dictionary<string, JsonDocument>>(""" 296AIFunctionArguments arguments = new(JsonSerializer.Deserialize<Dictionary<string, object?>>(""" 314AIFunctionArguments arguments = new(JsonSerializer.Deserialize<Dictionary<string, JsonNode>>(""" 348argumentParser: static json => JsonSerializer.Deserialize<Dictionary<string, object?>>(json, AIJsonUtilities.DefaultOptions));
Contents\FunctionResultContentTests.cs (4)
68var json = JsonSerializer.Serialize(sut, TestJsonSerializerContext.Default.Options); 70var deserializedSut = JsonSerializer.Deserialize<FunctionResultContent>(json, TestJsonSerializerContext.Default.Options); 85var json = JsonSerializer.Serialize(sut, TestJsonSerializerContext.Default.Options); 86var deserializedSut = JsonSerializer.Deserialize<FunctionResultContent>(json, TestJsonSerializerContext.Default.Options);
Contents\HostedFileContentTests.cs (2)
59var json = JsonSerializer.Serialize(content, AIJsonUtilities.DefaultOptions); 60var deserializedContent = JsonSerializer.Deserialize<HostedFileContent>(json, AIJsonUtilities.DefaultOptions);
Contents\HostedVectorStoreContentTests.cs (2)
59var json = JsonSerializer.Serialize(content, AIJsonUtilities.DefaultOptions); 60var deserializedContent = JsonSerializer.Deserialize<HostedVectorStoreContent>(json, AIJsonUtilities.DefaultOptions);
Contents\ImageGenerationToolCallContentTests.cs (4)
48var json = JsonSerializer.Serialize(content, AIJsonUtilities.DefaultOptions); 49var deserializedSut = JsonSerializer.Deserialize<ImageGenerationToolCallContent>(json, AIJsonUtilities.DefaultOptions); 63var json = JsonSerializer.Serialize(content, AIJsonUtilities.DefaultOptions); 67var deserialized = JsonSerializer.Deserialize<AIContent>(json, AIJsonUtilities.DefaultOptions);
Contents\ImageGenerationToolResultContentTests.cs (4)
81var json = JsonSerializer.Serialize(content, AIJsonUtilities.DefaultOptions); 82var deserializedSut = JsonSerializer.Deserialize<ImageGenerationToolResultContent>(json, AIJsonUtilities.DefaultOptions); 107var json = JsonSerializer.Serialize(content, AIJsonUtilities.DefaultOptions); 111var deserialized = JsonSerializer.Deserialize<AIContent>(json, AIJsonUtilities.DefaultOptions);
Contents\McpServerToolResultContentTests.cs (2)
61var json = JsonSerializer.Serialize(content, AIJsonUtilities.DefaultOptions); 62var deserializedContent = JsonSerializer.Deserialize<McpServerToolResultContent>(json, AIJsonUtilities.DefaultOptions);
Contents\TextContentTests.cs (2)
57var json = JsonSerializer.Serialize(content, AIJsonUtilities.DefaultOptions); 58var deserializedContent = JsonSerializer.Deserialize<TextContent>(json, AIJsonUtilities.DefaultOptions);
Contents\TextReasoningContentTests.cs (2)
64var json = JsonSerializer.Serialize(content, AIJsonUtilities.DefaultOptions); 65var deserializedContent = JsonSerializer.Deserialize<TextReasoningContent>(json, AIJsonUtilities.DefaultOptions);
Contents\UriContentTests.cs (1)
69JsonSerializer.Serialize(
Contents\UsageContentTests.cs (2)
74var json = JsonSerializer.Serialize(content, AIJsonUtilities.DefaultOptions); 75var deserializedContent = JsonSerializer.Deserialize<UsageContent>(json, AIJsonUtilities.DefaultOptions);
Contents\UserInputRequestContentTests.cs (4)
37var serializedContent = JsonSerializer.Serialize(content, AIJsonUtilities.DefaultOptions); 38var deserializedContent = JsonSerializer.Deserialize<UserInputRequestContent>(serializedContent, AIJsonUtilities.DefaultOptions); 48var serializedContents = JsonSerializer.Serialize(contents, TestJsonSerializerContext.Default.UserInputRequestContentArray); 49var deserializedContents = JsonSerializer.Deserialize(serializedContents, TestJsonSerializerContext.Default.UserInputRequestContentArray);
Contents\UserInputResponseContentTests.cs (4)
35var serializedContent = JsonSerializer.Serialize(content, AIJsonUtilities.DefaultOptions); 36var deserializedContent = JsonSerializer.Deserialize<UserInputResponseContent>(serializedContent, AIJsonUtilities.DefaultOptions); 46var serializedContents = JsonSerializer.Serialize(contents, TestJsonSerializerContext.Default.UserInputResponseContentArray); 47var deserializedContents = JsonSerializer.Deserialize(serializedContents, TestJsonSerializerContext.Default.UserInputResponseContentArray);
Embeddings\BinaryEmbeddingTests.cs (4)
69string json = JsonSerializer.Serialize(e, TestJsonSerializerContext.Default.Embedding); 72BinaryEmbedding result = Assert.IsType<BinaryEmbedding>(JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.Embedding)); 80BinaryEmbedding result = Assert.IsType<BinaryEmbedding>(JsonSerializer.Deserialize( 94Assert.Throws<JsonException>(() => JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.Embedding));
Embeddings\EmbeddingGenerationOptionsTests.cs (2)
77string json = JsonSerializer.Serialize(options, TestJsonSerializerContext.Default.EmbeddingGenerationOptions); 79EmbeddingGenerationOptions? deserialized = JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.EmbeddingGenerationOptions);
Embeddings\EmbeddingTests.cs (10)
45string json = JsonSerializer.Serialize(e, TestJsonSerializerContext.Default.Embedding); 48Embedding<byte> result = Assert.IsType<Embedding<byte>>(JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.Embedding)); 58string json = JsonSerializer.Serialize(e, TestJsonSerializerContext.Default.Embedding); 61Embedding<sbyte> result = Assert.IsType<Embedding<sbyte>>(JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.Embedding)); 72string json = JsonSerializer.Serialize(e, TestJsonSerializerContext.Default.Embedding); 75Embedding<Half> result = Assert.IsType<Embedding<Half>>(JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.Embedding)); 86string json = JsonSerializer.Serialize(e, TestJsonSerializerContext.Default.Embedding); 89Embedding<float> result = Assert.IsType<Embedding<float>>(JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.Embedding)); 99string json = JsonSerializer.Serialize(e, TestJsonSerializerContext.Default.Embedding); 102Embedding<double> result = Assert.IsType<Embedding<double>>(JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.Embedding));
HostedMcpServerToolApprovalModeTests.cs (6)
21string json = JsonSerializer.Serialize(HostedMcpServerToolApprovalMode.NeverRequire, TestJsonSerializerContext.Default.HostedMcpServerToolApprovalMode); 24HostedMcpServerToolApprovalMode? result = JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.HostedMcpServerToolApprovalMode); 31string json = JsonSerializer.Serialize(HostedMcpServerToolApprovalMode.AlwaysRequire, TestJsonSerializerContext.Default.HostedMcpServerToolApprovalMode); 34HostedMcpServerToolApprovalMode? result = JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.HostedMcpServerToolApprovalMode); 42string json = JsonSerializer.Serialize(requireSpecific, TestJsonSerializerContext.Default.HostedMcpServerToolApprovalMode); 45HostedMcpServerToolApprovalMode? result = JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.HostedMcpServerToolApprovalMode);
Image\ImageGenerationOptionsTests.cs (4)
75string json = JsonSerializer.Serialize(options, TestJsonSerializerContext.Default.ImageGenerationOptions); 77ImageGenerationOptions? deserialized = JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.ImageGenerationOptions); 130string json = JsonSerializer.Serialize(responseFormat, TestJsonSerializerContext.Default.ImageGenerationResponseFormat); 131ImageGenerationResponseFormat deserialized = JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.ImageGenerationResponseFormat);
Image\ImageGenerationResponseTests.cs (6)
105string json = JsonSerializer.Serialize(response, TestJsonSerializerContext.Default.ImageGenerationResponse); 107ImageGenerationResponse? deserialized = JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.ImageGenerationResponse); 126string json = JsonSerializer.Serialize(response, TestJsonSerializerContext.Default.ImageGenerationResponse); 128ImageGenerationResponse? deserialized = JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.ImageGenerationResponse); 144string json = JsonSerializer.Serialize(response, TestJsonSerializerContext.Default.ImageGenerationResponse); 146ImageGenerationResponse? deserialized = JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.ImageGenerationResponse);
ResponseContinuationTokenTests.cs (2)
29string json = JsonSerializer.Serialize(originalToken, TestJsonSerializerContext.Default.ResponseContinuationToken); 31ResponseContinuationToken? deserializedToken = JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.ResponseContinuationToken);
SpeechToText\SpeechToTextOptionsTests.cs (2)
75string json = JsonSerializer.Serialize(options, TestJsonSerializerContext.Default.SpeechToTextOptions); 77SpeechToTextOptions? deserialized = JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.SpeechToTextOptions);
SpeechToText\SpeechToTextResponseTests.cs (2)
164string json = JsonSerializer.Serialize(original, TestJsonSerializerContext.Default.SpeechToTextResponse); 166SpeechToTextResponse? result = JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.SpeechToTextResponse);
SpeechToText\SpeechToTextResponseUpdateKindTests.cs (2)
59string json = JsonSerializer.Serialize(kind, TestJsonSerializerContext.Default.SpeechToTextResponseUpdateKind); 62var result = JsonSerializer.Deserialize<SpeechToTextResponseUpdateKind>(json, TestJsonSerializerContext.Default.SpeechToTextResponseUpdateKind);
SpeechToText\SpeechToTextResponseUpdateTests.cs (2)
98string json = JsonSerializer.Serialize(original, TestJsonSerializerContext.Default.SpeechToTextResponseUpdate); 99SpeechToTextResponseUpdate? result = JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.SpeechToTextResponseUpdate);
test\Shared\JsonSchemaExporter\SchemaTestHelpers.cs (2)
69JsonSchema jsonSchema = JsonSerializer.Deserialize(schema, Context.Default.JsonSchema)!; 75JsonSerializer.Serialize(node, Context.Default.JsonNode!);
UsageDetailsTests.cs (4)
158string json = JsonSerializer.Serialize(details, AIJsonUtilities.DefaultOptions); 159UsageDetails? deserialized = JsonSerializer.Deserialize<UsageDetails>(json, AIJsonUtilities.DefaultOptions); 180string json = JsonSerializer.Serialize(details, AIJsonUtilities.DefaultOptions); 181UsageDetails? deserialized = JsonSerializer.Deserialize<UsageDetails>(json, AIJsonUtilities.DefaultOptions);
Utilities\AIJsonUtilitiesTests.cs (10)
57string json = JsonSerializer.Serialize(input, options); 69Assert.Equal(!isDotnetCore, JsonSerializer.IsReflectionEnabledByDefault); 70Assert.Equal(JsonSerializer.IsReflectionEnabledByDefault, AIJsonUtilities.DefaultOptions.TryGetTypeInfo(anonType, out _)); 490JsonNode? schemaAsNode = JsonSerializer.SerializeToNode(schema, options); 503JsonNode? serializedValue = JsonSerializer.SerializeToNode(testData.Value, testData.Type, options); 543AssertDeepEquals(JsonSerializer.Deserialize( 779AssertDeepEquals(JsonSerializer.Deserialize( 1055string json = JsonSerializer.Serialize(c, options); 1058AIContent? deserialized = JsonSerializer.Deserialize<AIContent>(json, options); 1096Assert.Throws<InvalidOperationException>(() => JsonSerializer.Serialize(c, options));
Microsoft.Extensions.AI.Evaluation.Quality (4)
ChatMessageExtensions.cs (1)
22JsonSerializer.SerializeToNode(
ChatResponseExtensions.cs (1)
37JsonSerializer.SerializeToNode(
IntentResolutionRating.cs (1)
79return JsonSerializer.Deserialize(trimmed, SerializerContext.Default.IntentResolutionRating)!;
RelevanceTruthAndCompletenessRating.cs (1)
78return JsonSerializer.Deserialize(trimmed, SerializerContext.Default.RelevanceTruthAndCompletenessRating)!;
Microsoft.Extensions.AI.Evaluation.Reporting (10)
Formats\Html\HtmlReportWriter.cs (1)
40string json = JsonSerializer.Serialize(dataset, JsonUtilities.Compact.DatasetTypeInfo);
Formats\Json\JsonReportWriter.cs (1)
45await JsonSerializer.SerializeAsync(
JsonSerialization\EvaluationContextConverter.cs (2)
69contents = JsonSerializer.Deserialize(ref reader, contentsTypeInfo) as IReadOnlyList<AIContent>; 91JsonSerializer.Serialize(writer, value.Contents, contentsTypeInfo);
Storage\DiskBasedResponseCache.CacheEntry.cs (4)
36JsonSerializer.Deserialize( 52await JsonSerializer.DeserializeAsync( 65JsonSerializer.Serialize(cacheEntryFile, this, JsonUtilities.Default.CacheEntryTypeInfo); 73await JsonSerializer.SerializeAsync(
Storage\DiskBasedResultStore.cs (2)
69await JsonSerializer.DeserializeAsync( 101await JsonSerializer.SerializeAsync(
Microsoft.Extensions.AI.Evaluation.Reporting.Azure (8)
src\Libraries\Microsoft.Extensions.AI.Evaluation.Reporting\CSharp\JsonSerialization\EvaluationContextConverter.cs (2)
69contents = JsonSerializer.Deserialize(ref reader, contentsTypeInfo) as IReadOnlyList<AIContent>; 91JsonSerializer.Serialize(writer, value.Contents, contentsTypeInfo);
Storage\AzureStorageResponseCache.CacheEntry.cs (4)
41JsonSerializer.Deserialize( 58await JsonSerializer.DeserializeAsync( 74JsonSerializer.Serialize(stream, this, AzureStorageJsonUtilities.Default.CacheEntryTypeInfo); 86await JsonSerializer.SerializeAsync(
Storage\AzureStorageResultStore.cs (2)
115ScenarioRunResult? result = await JsonSerializer.DeserializeAsync( 166await JsonSerializer.SerializeAsync(
Microsoft.Extensions.AI.Evaluation.Reporting.Tests (36)
CacheEntryTests.cs (4)
26string json = JsonSerializer.Serialize(entry, JsonUtilities.Default.CacheEntryTypeInfo); 27CacheEntry? deserialized = JsonSerializer.Deserialize(json, JsonUtilities.Default.CacheEntryTypeInfo); 46string json = JsonSerializer.Serialize(entry, JsonUtilities.Compact.CacheEntryTypeInfo); 47CacheEntry? deserialized = JsonSerializer.Deserialize(json, JsonUtilities.Default.CacheEntryTypeInfo);
ChatTurnDetailsTests.cs (18)
24ChatTurnDetails? details = JsonSerializer.Deserialize<ChatTurnDetails>(json, options); 34string roundTripJson = JsonSerializer.Serialize(details, options); 35ChatTurnDetails? deserializedDetails = JsonSerializer.Deserialize<ChatTurnDetails>(roundTripJson, options); 58ChatTurnDetails? details = JsonSerializer.Deserialize<ChatTurnDetails>(json, options); 68string roundTripJson = JsonSerializer.Serialize(details, options); 69ChatTurnDetails? deserializedDetails = JsonSerializer.Deserialize<ChatTurnDetails>(roundTripJson, options); 93ChatTurnDetails? details = JsonSerializer.Deserialize<ChatTurnDetails>(json, options); 103string roundTripJson = JsonSerializer.Serialize(details, options); 104ChatTurnDetails? deserializedDetails = JsonSerializer.Deserialize<ChatTurnDetails>(roundTripJson, options); 129ChatTurnDetails? details = JsonSerializer.Deserialize<ChatTurnDetails>(json, options); 142string roundTripJson = JsonSerializer.Serialize(details, options); 143ChatTurnDetails? deserializedDetails = JsonSerializer.Deserialize<ChatTurnDetails>(roundTripJson, options); 171ChatTurnDetails? details = JsonSerializer.Deserialize<ChatTurnDetails>(json, options); 184string roundTripJson = JsonSerializer.Serialize(details, options); 185ChatTurnDetails? deserializedDetails = JsonSerializer.Deserialize<ChatTurnDetails>(roundTripJson, options); 214ChatTurnDetails? details = JsonSerializer.Deserialize<ChatTurnDetails>(json, options); 227string roundTripJson = JsonSerializer.Serialize(details, options); 228ChatTurnDetails? deserializedDetails = JsonSerializer.Deserialize<ChatTurnDetails>(roundTripJson, options);
ScenarioRunResultTests.cs (6)
95string json = JsonSerializer.Serialize(entry, JsonUtilities.Default.ScenarioRunResultTypeInfo); 96ScenarioRunResult? deserialized = JsonSerializer.Deserialize(json, JsonUtilities.Default.ScenarioRunResultTypeInfo); 189string json = JsonSerializer.Serialize(dataset, JsonUtilities.Compact.DatasetTypeInfo); 190Dataset? deserialized = JsonSerializer.Deserialize(json, JsonUtilities.Default.DatasetTypeInfo); 219string defaultJson = JsonSerializer.Serialize(entry, JsonUtilities.Default.CacheEntryTypeInfo); 220string compactJson = JsonSerializer.Serialize(entry, JsonUtilities.Compact.CacheEntryTypeInfo);
SerializationChainingTests.cs (8)
59string text = JsonSerializer.Serialize(_scenarioRunResult, JsonUtilities.Default.ScenarioRunResultTypeInfo); 60ScenarioRunResult? response = JsonSerializer.Deserialize(text, JsonUtilities.Default.ScenarioRunResultTypeInfo); 68string text = JsonSerializer.Serialize(_scenarioRunResult, JsonUtilities.Compact.ScenarioRunResultTypeInfo); 69ScenarioRunResult? response = JsonSerializer.Deserialize(text, JsonUtilities.Compact.ScenarioRunResultTypeInfo); 77string text = JsonSerializer.Serialize(_scenarioRunResult, AzureStorageJsonUtilities.Default.ScenarioRunResultTypeInfo); 78ScenarioRunResult? response = JsonSerializer.Deserialize(text, AzureStorageJsonUtilities.Default.ScenarioRunResultTypeInfo); 86string text = JsonSerializer.Serialize(_scenarioRunResult, AzureStorageJsonUtilities.Compact.ScenarioRunResultTypeInfo); 87ScenarioRunResult? response = JsonSerializer.Deserialize(text, AzureStorageJsonUtilities.Compact.ScenarioRunResultTypeInfo);
Microsoft.Extensions.AI.Evaluation.Tests (4)
IntentResolutionRatingTests.cs (2)
118string json = JsonSerializer.Serialize(rating, SerializerContext.Default.IntentResolutionRating); 136string json = JsonSerializer.Serialize(rating, SerializerContext.Default.IntentResolutionRating);
RelevanceTruthAndCompletenessRatingTests.cs (2)
142string json = JsonSerializer.Serialize(rating, SerializerContext.Default.RelevanceTruthAndCompletenessRating); 162string json = JsonSerializer.Serialize(rating, SerializerContext.Default.RelevanceTruthAndCompletenessRating);
Microsoft.Extensions.AI.Integration.Tests (9)
PromptBasedFunctionCallingChatClient.cs (4)
71var toolCallResultJson = JsonSerializer.Serialize(new ToolCallResult { Id = frc.CallId, Result = frc.Result }, _jsonOptions); 76var toolCallJson = JsonSerializer.Serialize(new { fcc.CallId, fcc.Name, fcc.Arguments }, _jsonOptions); 109var toolCallParsed = JsonSerializer.Deserialize<ToolCall>(ref reader, _jsonOptions); 169var toolDescriptorsJson = JsonSerializer.Serialize(tools.OfType<AIFunction>().Select(t => t.JsonSchema), _jsonOptions);
VerbatimMultiPartHttpHandler.cs (5)
138var jsonParameters = JsonSerializer.Serialize(parameters); 156return JsonSerializer.SerializeToElement(intValue); 161return JsonSerializer.SerializeToElement(doubleValue); 167return JsonSerializer.SerializeToElement(boolValue); 171return JsonSerializer.SerializeToElement(content);
Microsoft.Extensions.AI.OpenAI (23)
MicrosoftExtensionsAIChatExtensions.cs (2)
75new BinaryData(JsonSerializer.SerializeToUtf8Bytes(c.Arguments, AIJsonUtilities.DefaultOptions.GetTypeInfo(typeof(IDictionary<string, object?>)))))); 160functionArgumentsUpdate: new(JsonSerializer.SerializeToUtf8Bytes(fcc.Arguments, AIJsonUtilities.DefaultOptions.GetTypeInfo(typeof(IDictionary<string, object?>))))))
OpenAIAssistantsChatClient.cs (3)
193JsonSerializer.Serialize([ru.Value.Id, toolCallId], OpenAIJsonContext.Default.StringArray), 476BinaryData.FromBytes(JsonSerializer.SerializeToUtf8Bytes(jsonSchema, OpenAIJsonContext.Default.JsonElement)), 585runAndCallIDs = JsonSerializer.Deserialize(frc.CallId, OpenAIJsonContext.Default.StringArray);
OpenAIChatClient.cs (3)
183result = JsonSerializer.Serialize(resultContent.Result, AIJsonUtilities.DefaultOptions.GetTypeInfo(typeof(object))); 210ChatToolCall.CreateFunctionToolCall(fc.CallId, fc.Name, new(JsonSerializer.SerializeToUtf8Bytes( 652BinaryData.FromBytes(JsonSerializer.SerializeToUtf8Bytes(jsonSchema, OpenAIJsonContext.Default.JsonElement)),
OpenAIClientExtensions.cs (4)
199var tool = JsonSerializer.Deserialize(jsonSchema, OpenAIJsonContext.Default.ToolJson)!; 200var functionParameters = BinaryData.FromBytes(JsonSerializer.SerializeToUtf8Bytes(tool, OpenAIJsonContext.Default.ToolJson)); 216static json => JsonSerializer.Deserialize(json, OpenAIJsonContext.Default.IDictionaryStringObject)!); 229static utf8json => JsonSerializer.Deserialize(utf8json, OpenAIJsonContext.Default.IDictionaryStringObject)!);
OpenAIImageGenerator.cs (1)
124var outputFormatString = JsonSerializer.Deserialize(outputFormat, stringJsonTypeInfo);
OpenAIResponsesChatClient.cs (10)
215Arguments = JsonSerializer.Deserialize(mtcari.ToolArguments.ToMemory().Span, OpenAIJsonContext.Default.IReadOnlyDictionaryStringObject)!, 452Arguments = JsonSerializer.Deserialize(mtcari.ToolArguments.ToMemory().Span, OpenAIJsonContext.Default.IReadOnlyDictionaryStringObject)!, 840BinaryData.FromBytes(JsonSerializer.SerializeToUtf8Bytes(jsonSchema, OpenAIJsonContext.Default.JsonElement)), 1070Text = JsonSerializer.Serialize(content, AIJsonUtilities.DefaultOptions.GetTypeInfo(typeof(object))), 1084outputItem.Patch.Set("$.output"u8, JsonSerializer.SerializeToUtf8Bytes(elements, OpenAIJsonContext.Default.ListFunctionToolCallOutputElement).AsSpan()); 1106result = JsonSerializer.Serialize(resultContent.Result, AIJsonUtilities.DefaultOptions.GetTypeInfo(typeof(object))); 1153BinaryData.FromBytes(JsonSerializer.SerializeToUtf8Bytes( 1163BinaryData.FromBytes(JsonSerializer.SerializeToUtf8Bytes(mcpApprovalRequestContent.ToolCall.Arguments!, OpenAIJsonContext.Default.IReadOnlyDictionaryStringObject))); 1178BinaryData.FromBytes(JsonSerializer.SerializeToUtf8Bytes(associatedCall.Arguments!, OpenAIJsonContext.Default.IReadOnlyDictionaryStringObject))); 1370Arguments = JsonSerializer.Deserialize(mtci.ToolArguments.ToMemory().Span, OpenAIJsonContext.Default.IReadOnlyDictionaryStringObject)!,
Microsoft.Extensions.AI.OpenAI.Tests (11)
OpenAIConversionTests.cs (4)
687Assert.True(JsonElement.DeepEquals(JsonSerializer.SerializeToElement(new Dictionary<string, object?> 743Assert.True(JsonElement.DeepEquals(JsonSerializer.SerializeToElement(new Dictionary<string, object?> 1077var deserializedArgs = JsonSerializer.Deserialize<Dictionary<string, object?>>(toolCall.FunctionArguments.ToMemory().Span); 1272var deserializedArgs = JsonSerializer.Deserialize<Dictionary<string, object?>>(
OpenAIResponseClientIntegrationTests.cs (4)
604string json = JsonSerializer.Serialize(chatHistory, AIJsonUtilities.DefaultOptions); 605var deserializedHistory = JsonSerializer.Deserialize<List<ChatMessage>>(json, AIJsonUtilities.DefaultOptions)!; 684string json = JsonSerializer.Serialize(chatHistory, AIJsonUtilities.DefaultOptions); 685var deserializedHistory = JsonSerializer.Deserialize<List<ChatMessage>>(json, AIJsonUtilities.DefaultOptions)!;
test\Libraries\Microsoft.Extensions.AI.Abstractions.Tests\AssertExtensions.cs (3)
100JsonSerializer.SerializeToNode(expectedJson, AIJsonUtilities.DefaultOptions), 101JsonSerializer.SerializeToNode(actualJson, AIJsonUtilities.DefaultOptions))) 119=> value is JsonElement e ? e : JsonSerializer.SerializeToElement(value, options);
Microsoft.Extensions.AI.Tests (24)
ChatCompletion\ChatClientStructuredOutputExtensionsTests.cs (9)
23var expectedResponse = new ChatResponse(new ChatMessage(ChatRole.Assistant, JsonSerializer.Serialize(expectedResult, JsonContext2.Default.Animal))) 100var expectedResponse = new ChatResponse(new ChatMessage(ChatRole.Assistant, JsonSerializer.Serialize(expectedResult, JsonContext2.Default.Options))) 161var expectedResponse = new ChatResponse(new ChatMessage(ChatRole.Assistant, JsonSerializer.Serialize(expectedResult, JsonContext2.Default.Options))); 204new ChatMessage(ChatRole.Assistant, JsonSerializer.Serialize(expectedResult, JsonContext2.Default.Options)) 297var expectedResponse = new ChatResponse(new ChatMessage(ChatRole.Assistant, JsonSerializer.Serialize(expectedResult, JsonContext2.Default.Options))); 332var expectedResponse = new ChatResponse(new ChatMessage(ChatRole.Assistant, JsonSerializer.Serialize(payload, JsonContext2.Default.Options))); 364var expectedResponse = new ChatResponse(new ChatMessage(ChatRole.Assistant, JsonSerializer.Serialize(expectedResult, jso))); 419var resultDuplicatedJson = JsonSerializer.Serialize(expectedResult, JsonContext2.Default.Options) + Environment.NewLine + JsonSerializer.Serialize(expectedResult, JsonContext2.Default.Options);
ChatCompletion\DistributedCachingChatClientTest.cs (6)
800JsonSerializer.Serialize(expected.AdditionalProperties, TestJsonSerializerContext.Default.Options), 801JsonSerializer.Serialize(actual.AdditionalProperties, TestJsonSerializerContext.Default.Options)); 825JsonSerializer.Serialize(expectedFcc.Arguments, TestJsonSerializerContext.Default.Options), 826JsonSerializer.Serialize(actualFcc.Arguments, TestJsonSerializerContext.Default.Options)); 859JsonSerializer.Serialize(expectedFcc.Arguments, TestJsonSerializerContext.Default.Options), 860JsonSerializer.Serialize(actualFcc.Arguments, TestJsonSerializerContext.Default.Options));
ChatCompletion\FunctionInvokingChatClientTests.cs (3)
347JsonSerializer.SerializeToElement($"{e.GetString()} from delegate", AIJsonUtilities.DefaultOptions) : 1142JsonSerializer.Serialize(new Dictionary<string, object?> { ["arg1"] = "value1" }, AIJsonUtilities.DefaultOptions), 1146Assert.Equal("Result 1", JsonSerializer.Deserialize<string>(result.Value!, AIJsonUtilities.DefaultOptions));
Embeddings\DistributedCachingEmbeddingGeneratorTest.cs (2)
409JsonSerializer.Serialize(expected.AdditionalProperties, TestJsonSerializerContext.Default.Options), 410JsonSerializer.Serialize(actual.AdditionalProperties, TestJsonSerializerContext.Default.Options));
Functions\AIFunctionFactoryTest.cs (1)
179JsonElement expectedResult = JsonDocument.Parse(JsonSerializer.Serialize(invalidJsonParam, JsonContext.Default.String)).RootElement;
test\Libraries\Microsoft.Extensions.AI.Abstractions.Tests\AssertExtensions.cs (3)
100JsonSerializer.SerializeToNode(expectedJson, AIJsonUtilities.DefaultOptions), 101JsonSerializer.SerializeToNode(actualJson, AIJsonUtilities.DefaultOptions))) 119=> value is JsonElement e ? e : JsonSerializer.SerializeToElement(value, options);
Microsoft.Extensions.Caching.Hybrid (2)
Internal\DefaultJsonSerializerFactory.cs (2)
151return JsonSerializer.Deserialize<T>(ref reader, Options)!; 159JsonSerializer.Serialize<T>(writer, value, Options);
Microsoft.Extensions.Caching.Hybrid.Tests (2)
SampleUsage.cs (2)
176return JsonSerializer.Deserialize<T>(bytes)!; 182JsonSerializer.Serialize(ms, info);
Microsoft.Extensions.DataIngestion.Tests (6)
Processors\AlternativeTextEnricherTests.cs (2)
61new ChatMessage(ChatRole.Assistant, JsonSerializer.Serialize(new Envelope<string[]> { data = descriptions })) 147return Task.FromResult(new ChatResponse(new[] { new ChatMessage(ChatRole.Assistant, JsonSerializer.Serialize(data)) }));
Processors\ClassificationEnricherTests.cs (1)
81string response = JsonSerializer.Serialize(new Envelope<string[]> { data = classes });
Processors\KeywordEnricherTests.cs (1)
81string response = JsonSerializer.Serialize(new Envelope<string[][]> { data = keywords });
Processors\SentimentEnricherTests.cs (1)
65string response = JsonSerializer.Serialize(new Envelope<string[]> { data = sentiments });
Processors\SummaryEnricherTests.cs (1)
65string response = JsonSerializer.Serialize(new Envelope<string[]> { data = summaries });
Microsoft.Extensions.Validation.GeneratorTests (1)
ValidationsGeneratorTestBase.cs (1)
596return JsonSerializer.Deserialize<HttpValidationProblemDetails>(responseBody);
Microsoft.JSInterop (8)
Infrastructure\DotNetDispatcher.cs (4)
64return JsonSerializer.Serialize(syncResult, jsRuntime.JsonSerializerOptions); 135var syncResultJson = JsonSerializer.Serialize(syncResult, jsRuntime.JsonSerializerOptions); 152var resultJson = JsonSerializer.Serialize(result, jsRuntime.JsonSerializerOptions); 246suppliedArgs[index] = JsonSerializer.Deserialize(ref reader, parameterType, jsRuntime.JsonSerializerOptions);
JSInProcessRuntime.cs (2)
47var argsJson = args is not null && args.Length != 0 ? JsonSerializer.Serialize(args, JsonSerializerOptions) : "[]"; 69var result = JsonSerializer.Deserialize<TValue>(resultJson, JsonSerializerOptions)!;
JSRuntime.cs (2)
153var argsJson = args is not null && args.Length != 0 ? JsonSerializer.Serialize(args, JsonSerializerOptions) : "[]"; 291var result = JsonSerializer.Deserialize(ref jsonReader, resultType, JsonSerializerOptions);
Microsoft.JSInterop.Tests (59)
Infrastructure\ByteArrayJsonConverterTest.cs (15)
25var ex = Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<byte[]>(json, JsonSerializerOptions)); 38var ex = Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<byte[]>(json, JsonSerializerOptions)); 51var ex = Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<byte[]>(json, JsonSerializerOptions)); 64var ex = Record.Exception(() => JsonSerializer.Deserialize<byte[]>(json, JsonSerializerOptions)); 73var json = JsonSerializer.Serialize(expected); 76var deserialized = JsonSerializer.Deserialize<byte[]>(json, JsonSerializerOptions)!; 89var ex = Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<byte[]>(json, JsonSerializerOptions)); 105var deserialized = JsonSerializer.Deserialize<byte[]>(json, JsonSerializerOptions)!; 121var ex = Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<byte[]>(json, JsonSerializerOptions)); 137var ex = Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<byte[]>(json, JsonSerializerOptions)); 153var ex = Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<byte[]>(json, JsonSerializerOptions)); 169var ex = Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<byte[]>(json, JsonSerializerOptions)); 188var deserialized = JsonSerializer.Deserialize<byte[]>(json, JsonSerializerOptions)!; 210var deserialized = JsonSerializer.Deserialize<byte[][]>(json, JsonSerializerOptions)!; 226var json = JsonSerializer.Serialize(byteArray, JsonSerializerOptions);
Infrastructure\DotNetDispatcherTest.cs (17)
92var result = JsonSerializer.Deserialize<TestDTO>(resultJson, jsRuntime.JsonSerializerOptions); 105var result = JsonSerializer.Deserialize<TestDTO>(resultJson, jsRuntime.JsonSerializerOptions); 122var argsJson = JsonSerializer.Serialize(new object[] 135var resultDto1 = JsonSerializer.Deserialize<TestDTO>(root[0].GetRawText(), jsRuntime.JsonSerializerOptions); 162var argsJson = JsonSerializer.Serialize(new object[] 270var argsJson = JsonSerializer.Serialize(new object[] { jsRuntime.LastInvocationAsyncHandle, true, testDTO }, jsRuntime.JsonSerializerOptions); 291var argsJson = JsonSerializer.Serialize(new object[] { jsRuntime.LastInvocationAsyncHandle, false, expected }, jsRuntime.JsonSerializerOptions); 307var argsJson = JsonSerializer.Serialize(new object[] { jsRuntime.LastInvocationAsyncHandle, false, null }, jsRuntime.JsonSerializerOptions); 324var argsJson = JsonSerializer.Serialize(new object[] { jsRuntime.LastInvocationAsyncHandle, true, testDTO }, jsRuntime.JsonSerializerOptions); 523var result = JsonSerializer.Deserialize<TestDTO>(resultJson, jsRuntime.JsonSerializerOptions); 526var result2 = JsonSerializer.Deserialize<TestDTO>(resultJson2, jsRuntime.JsonSerializerOptions); 581var argsJson = JsonSerializer.Serialize(new object[] 602var argsJson = JsonSerializer.Serialize(new object[] 631var argsJson = JsonSerializer.Serialize(new object[] 647var result = JsonSerializer.Deserialize<SomePublicType.InvokableAsyncMethodResult>(resultJson, jsRuntime.JsonSerializerOptions); 670var argsJson = JsonSerializer.Serialize(new object[] 698var argsJson = JsonSerializer.Serialize(new object[] { }, jsRuntime.JsonSerializerOptions);
Infrastructure\DotNetObjectReferenceJsonConverterTest.cs (9)
23var ex = Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<DotNetObjectReference<TestModel>>(json, JsonSerializerOptions)); 37var ex = Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<DotNetObjectReference<TestModel>>(json, JsonSerializerOptions)); 52var ex = Record.Exception(() => JsonSerializer.Deserialize<DotNetObjectReference<TestModel>>(json, JsonSerializerOptions)); 67var ex = Record.Exception(() => JsonSerializer.Deserialize<DotNetObjectReference<TestModel>>(json, JsonSerializerOptions)); 82var deserialized = JsonSerializer.Deserialize<DotNetObjectReference<TestModel>>(json, JsonSerializerOptions)!; 102var deserialized = JsonSerializer.Deserialize<DotNetObjectReference<TestModel>[]>(json, JsonSerializerOptions)!; 123var deserialized = JsonSerializer.Deserialize<DotNetObjectReference<TestModel>>(json, JsonSerializerOptions)!; 137var json1 = JsonSerializer.Serialize(dotNetObjectRef, JsonSerializerOptions); 138var json2 = JsonSerializer.Serialize(dotNetObjectRef, JsonSerializerOptions);
Infrastructure\DotNetStreamReferenceJsonConverterTest.cs (3)
26var ex = Assert.Throws<NotSupportedException>(() => JsonSerializer.Deserialize<DotNetStreamReference>(json, JsonSerializerOptions)); 37var json = JsonSerializer.Serialize(streamRef, JsonSerializerOptions); 52var json = JsonSerializer.Serialize(streamRef, JsonSerializerOptions);
Infrastructure\JSObjectReferenceJsonConverterTest.cs (7)
27var ex = Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<IJSObjectReference>(json, JsonSerializerOptions)); 38var ex = Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<IJSObjectReference>(json, JsonSerializerOptions)); 49var ex = Record.Exception(() => JsonSerializer.Deserialize<IJSObjectReference>(json, JsonSerializerOptions)); 60var ex = Record.Exception(() => JsonSerializer.Deserialize<IJSObjectReference>(json, JsonSerializerOptions)); 72var deserialized = (JSObjectReference)JsonSerializer.Deserialize<IJSObjectReference>(json, JsonSerializerOptions)!; 85var json = JsonSerializer.Serialize((IJSObjectReference)jsObjectRef, JsonSerializerOptions); 98var deserialized = JsonSerializer.Deserialize<IJSObjectReference>(json, JsonSerializerOptions);
Infrastructure\JSStreamReferenceJsonConverterTest.cs (8)
27var ex = Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<IJSStreamReference>(json, JsonSerializerOptions)); 38var ex = Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<IJSStreamReference>(json, JsonSerializerOptions)); 49var ex = Record.Exception(() => JsonSerializer.Deserialize<IJSStreamReference>(json, JsonSerializerOptions)); 60var ex = Record.Exception(() => JsonSerializer.Deserialize<IJSStreamReference>(json, JsonSerializerOptions)); 72var ex = Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<IJSStreamReference>(json, JsonSerializerOptions)); 85var deserialized = (JSStreamReference)JsonSerializer.Deserialize<IJSStreamReference>(json, JsonSerializerOptions)!; 101var deserialized = (JSStreamReference)JsonSerializer.Deserialize<IJSStreamReference>(json, JsonSerializerOptions)!; 115var json = JsonSerializer.Serialize((IJSStreamReference)jsObjectRef, JsonSerializerOptions);
Microsoft.Maui (7)
Handlers\HybridWebView\HybridWebViewHandler.cs (7)
150 var jsError = JsonSerializer.Deserialize(result, HybridWebViewHandlerJsonContext.Default.JSInvokeError); 184 var invokeData = JsonSerializer.Deserialize<JSInvokeMethodData>(invokeDataString, HybridWebViewHandlerJsonContext.Default.JSInvokeMethodData); 192 var json = JsonSerializer.Serialize(invokeResult); 219 Result = JsonSerializer.Serialize(result), 260 var deserialized = JsonSerializer.Deserialize(reqValue, paramType); 408 invokeJavaScriptRequest.ParamValues.Select((v, i) => (v == null ? "null" : JsonSerializer.Serialize(v, invokeJavaScriptRequest.ParamJsonTypeInfos![i]!)))); 428 var typedResult = JsonSerializer.Deserialize(stringResult, invokeJavaScriptRequest.ReturnTypeJsonTypeInfo);
Microsoft.ML.AutoML (5)
AutoMLExperiment\AutoMLExperiment.cs (4)
272logger.Trace($"trial setting - {JsonSerializer.Serialize(trialSettings)}"); 299Exception thrown during Trial {trialSettings.TrialId} with configuration {JsonSerializer.Serialize(trialSettings)} 320logger.Trace($"trial fatal error - {JsonSerializer.Serialize(trialSettings)}, stop training"); 332logger.Trace($"trial cancelled - {JsonSerializer.Serialize(trialSettings)}, stop training");
Tuner\AutoZeroTuner.cs (1)
73var res = JsonSerializer.Deserialize<List<Config>>(json);
Microsoft.ML.AutoML.Interactive (4)
AutoMLMonitorKernelExtension.cs (3)
25Formatter.Register<Parameter>((parameter) => JsonSerializer.Serialize(parameter, new JsonSerializerOptions() { WriteIndented = true, })); 52var bestTrialParam = JsonSerializer.Serialize(monitor.BestTrial.TrialSettings.Parameter, new JsonSerializerOptions() { WriteIndented = true, }); 61var activeTrialParam = JsonSerializer.Serialize(monitor.ActiveTrial.Parameter, new JsonSerializerOptions() { WriteIndented = true, });
NotebookMonitor.cs (1)
47var activeRunParam = JsonSerializer.Serialize(result.TrialSettings.Parameter, new JsonSerializerOptions() { WriteIndented = false, });
Microsoft.ML.AutoML.SourceGenerator (5)
EstimatorTypeGenerator.cs (1)
28var flags = JsonSerializer.Deserialize<Dictionary<string, bool>>(json);
SearchSpaceGenerator.cs (1)
25var flags = JsonSerializer.Deserialize<Dictionary<string, bool>>(json);
SweepableEstimatorFactoryGenerator.cs (1)
25var flags = JsonSerializer.Deserialize<Dictionary<string, bool>>(json);
SweepableEstimatorGenerator.cs (1)
24var flags = JsonSerializer.Deserialize<Dictionary<string, bool>>(json);
Utils.cs (1)
17return JsonSerializer.Deserialize<EstimatorsContract>(json);
Microsoft.ML.AutoML.Tests (17)
AutoFeaturizerTests.cs (6)
50Approvals.Verify(JsonSerializer.Serialize(pipeline, _jsonSerializerOptions)); 62Approvals.Verify(JsonSerializer.Serialize(pipeline, _jsonSerializerOptions)); 74Approvals.Verify(JsonSerializer.Serialize(pipeline, _jsonSerializerOptions)); 86Approvals.Verify(JsonSerializer.Serialize(pipeline, _jsonSerializerOptions)); 97Approvals.Verify(JsonSerializer.Serialize(pipeline, _jsonSerializerOptions)); 113Approvals.Verify(JsonSerializer.Serialize(pipeline, _jsonSerializerOptions));
SweepableEstimatorPipelineTest.cs (1)
122Approvals.Verify(JsonSerializer.Serialize(defaultParam, _jsonSerializerOptions));
SweepableExtensionTest.cs (9)
84var json = JsonSerializer.Serialize(pipeline, _jsonSerializerOptions); 97var json = JsonSerializer.Serialize(pipeline, _jsonSerializerOptions); 110var json = JsonSerializer.Serialize(pipeline, _jsonSerializerOptions); 123var json = JsonSerializer.Serialize(pipeline, _jsonSerializerOptions); 137var json = JsonSerializer.Serialize(pipeline, _jsonSerializerOptions); 151var json = JsonSerializer.Serialize(pipeline, _jsonSerializerOptions); 164var json = JsonSerializer.Serialize(pipeline, _jsonSerializerOptions); 177var json = JsonSerializer.Serialize(pipeline, _jsonSerializerOptions); 192var json = JsonSerializer.Serialize(pipeline, _jsonSerializerOptions);
SweepablePipelineTests.cs (1)
70Approvals.Verify(JsonSerializer.Serialize(pipeline, _jsonSerializerOptions));
Microsoft.ML.GenAI.LLaMA (7)
LlamaConfig.cs (5)
52Llama3_1_8B_Instruct = JsonSerializer.Deserialize<LlamaConfig>(llama3_1_8b_content) ?? throw new ArgumentNullException(nameof(llama3_1_8b_content)); 53Llama3_1_70B_Instruct = JsonSerializer.Deserialize<LlamaConfig>(llama3_1_70b_content) ?? throw new ArgumentNullException(nameof(llama3_1_70b_content)); 54Llama3_1_405B_Instruct = JsonSerializer.Deserialize<LlamaConfig>(llama3_1_405b_content) ?? throw new ArgumentNullException(nameof(llama3_1_405b_content)); 55Llama3_2_1B_Instruct = JsonSerializer.Deserialize<LlamaConfig>(llama3_2_1b_content) ?? throw new ArgumentNullException(nameof(llama3_2_1b_content)); 56Llama_3_2_3B_Instruct = JsonSerializer.Deserialize<LlamaConfig>(llama3_2_3b_content) ?? throw new ArgumentNullException(nameof(llama3_2_3b_content));
LlamaForCausalLM.cs (2)
103var modelConfig = JsonSerializer.Deserialize<LlamaConfig>(File.ReadAllText(config)) ?? throw new ArgumentNullException(nameof(config)); 136var modelConfig = JsonSerializer.Deserialize<LlamaConfig>(File.ReadAllText(config)) ?? throw new ArgumentNullException(nameof(config));
Microsoft.ML.GenAI.Mistral (8)
Mistral_7B_0_3ChatTemplateBuilder.cs (3)
77var schemaPrompt = JsonSerializer.Serialize(schemas); 130var toolCallJson = JsonSerializer.Serialize(toolCallObjects); 152var toolCallResultJson = JsonSerializer.Serialize(toolCallResultObjects);
MistralCausalLMAgent.cs (2)
149var mistralToolCalls = JsonSerializer.Deserialize<List<MistralToolCall>>(json) ?? throw new InvalidOperationException("Failed to deserialize tool calls."); 151.Select(tc => new ToolCall(tc.Name!, JsonSerializer.Serialize(tc.Arguments)) { ToolCallId = this.GenerateToolCallId() });
MistralConfig.cs (1)
44Mistral_7B_Instruct_v0_3 = JsonSerializer.Deserialize<MistralConfig>(mistral7BInstructContent) ?? throw new ArgumentNullException(nameof(mistral7BInstructContent));
MistralForCausalLM.cs (2)
58var modelConfig = JsonSerializer.Deserialize<MistralConfig>(File.ReadAllText(config)) ?? throw new ArgumentNullException(nameof(config)); 86var modelConfig = JsonSerializer.Deserialize<MistralConfig>(File.ReadAllText(config)) ?? throw new ArgumentNullException(nameof(config));
Microsoft.ML.GenAI.Phi (8)
Phi2\Config.cs (1)
45var phi2Config = JsonSerializer.Deserialize<Phi2Config>(phi2ConfigContent) ?? throw new ArgumentNullException(nameof(phi2ConfigContent));
Phi2\Phi2ForCausalLM.cs (1)
59var modelConfig = JsonSerializer.Deserialize<Phi2Config>(File.ReadAllText(config)) ?? throw new ArgumentNullException(nameof(config));
Phi3\Config.cs (4)
51Phi3Mini4kInstruct = JsonSerializer.Deserialize<Phi3Config>(phi3Mini4kInstructContent) ?? throw new ArgumentNullException(nameof(phi3Mini4kInstructContent)); 52Phi3Mini128kInstruct = JsonSerializer.Deserialize<Phi3Config>(phi3Mini128kInstructContent) ?? throw new ArgumentNullException(nameof(phi3Mini128kInstructContent)); 53Phi3Medium4kInstruct = JsonSerializer.Deserialize<Phi3Config>(phi3Medium4kInstructContent) ?? throw new ArgumentNullException(nameof(phi3Medium4kInstructContent)); 54Phi3Medium128kInstruct = JsonSerializer.Deserialize<Phi3Config>(phi3Medium128kInstructContent) ?? throw new ArgumentNullException(nameof(phi3Medium128kInstructContent));
Phi3\Phi3ForCausalLM.cs (2)
60var modelConfig = JsonSerializer.Deserialize<Phi3Config>(File.ReadAllText(config)) ?? throw new ArgumentNullException(nameof(config)); 88var modelConfig = JsonSerializer.Deserialize<Phi3Config>(File.ReadAllText(config)) ?? throw new ArgumentNullException(nameof(config));
Microsoft.ML.GenAI.Phi.Tests (1)
Phi3Tests.cs (1)
109var json = JsonSerializer.Serialize(sizeInMB, new JsonSerializerOptions { WriteIndented = true });
Microsoft.ML.GenAI.Samples (2)
Mistral\Mistral_7B_Instruct.cs (1)
76var mistralConfig = JsonSerializer.Deserialize<MistralConfig>(File.ReadAllText(Path.Combine(weightFolder, configName))) ?? throw new ArgumentNullException(nameof(configName));
Mistral_7B_Instruct_84ea5663-ef77-4541-a466-c5fdf2312634.generated.cs (1)
25var schema = JsonSerializer.Deserialize<GetWeatherSchema>(
Microsoft.ML.SearchSpace (24)
Converter\ChoiceOptionConverter.cs (2)
30var schema = JsonSerializer.Deserialize<Schema>(ref reader, options); 43JsonSerializer.Serialize(writer, schema, options);
Converter\NumericOptionConverter.cs (2)
39var schema = JsonSerializer.Deserialize<Schema>(ref reader, options); 81JsonSerializer.Serialize(writer, schema, options);
Converter\OptionConverter.cs (6)
20return JsonSerializer.Deserialize<SearchSpace>(ref reader, options); 29return JsonSerializer.Deserialize<ChoiceOption>(ref reader, options); 38return JsonSerializer.Deserialize<UniformNumericOption>(ref reader, options); 50JsonSerializer.Serialize(writer, ss, options); 54JsonSerializer.Serialize(writer, choiceOption, options); 58JsonSerializer.Serialize(writer, uniformNumericOption, options);
Converter\ParameterConverter.cs (4)
20var array = JsonSerializer.Deserialize<Dictionary<string, Parameter>>(ref reader, options).ToArray(); 23return Parameter.FromString(JsonSerializer.Deserialize<string>(ref reader, options)); 34return Parameter.FromDouble(JsonSerializer.Deserialize<double>(ref reader, options)); 56JsonSerializer.Serialize(writer, value.Value, options);
Converter\SearchSpaceConverter.cs (2)
18var optionKVPairs = JsonSerializer.Deserialize<Dictionary<string, OptionBase>>(ref reader, options); 25JsonSerializer.Serialize<IDictionary<string, OptionBase>>(value, options);
Parameter.cs (7)
286/// Cast <see cref="ParameterType"/> to <typeparamref name="T"/>. This method will return immediately if the underlying value is of type <typeparamref name="T"/>, otherwise it uses <see cref="JsonSerializer"/> to 297var json = JsonSerializer.Serialize(_value, _settings); 298return JsonSerializer.Deserialize<T>(json, _settings); 393var thisJson = JsonSerializer.Serialize(this); 394var otherJson = JsonSerializer.Serialize(other); 402var thisJson = JsonSerializer.Serialize(this); 426return JsonSerializer.Serialize(this);
SearchSpace.cs (1)
157var json = JsonSerializer.Serialize(parameter);
Microsoft.ML.SearchSpace.Tests (6)
ParameterTest.cs (5)
40var json = JsonSerializer.Serialize(parameter, _settings); 43parameter = JsonSerializer.Deserialize<Parameter>(json); 109var json = JsonSerializer.Serialize(parameter, _settings); 112parameter = JsonSerializer.Deserialize<Parameter>(json); 119json = JsonSerializer.Serialize(parameter, _settings);
SearchSpaceTest.cs (1)
303var json = JsonSerializer.Serialize(ss, _settings);
Microsoft.ML.Tokenizers (5)
Model\BpeOptions.cs (1)
50Dictionary<string, int>? dictionary = JsonSerializer.Deserialize<Dictionary<string, int>>(vocabStream);
Model\BPETokenizer.cs (2)
1102? await JsonSerializer.DeserializeAsync(vocab, ModelSourceGenerationContext.Default.DictionaryStringSpanOrdinalKeyInt32, cancellationToken).ConfigureAwait(false) 1103: JsonSerializer.Deserialize(vocab, ModelSourceGenerationContext.Default.DictionaryStringSpanOrdinalKeyInt32);
Model\CodeGenTokenizer.cs (1)
1752vocab = JsonSerializer.Deserialize(vocabularyStream, ModelSourceGenerationContext.Default.Vocabulary);
Model\EnglishRobertaTokenizer.cs (1)
184vocab = JsonSerializer.Deserialize(vocabularyStream, ModelSourceGenerationContext.Default.DictionaryStringSpanOrdinalKeyInt32);
Microsoft.ML.Tokenizers.Tests (8)
BpeTests.cs (2)
400Dictionary<string, int>? dictionary = JsonSerializer.Deserialize<Dictionary<string, int>>(jsonString); 592File.WriteAllText(fileName, JsonSerializer.Serialize<Dictionary<string, int>>(dic), Encoding.UTF8);
TiktokenTests.cs (6)
227int[]? expected = JsonSerializer.Deserialize<int[]>(stream) as int[]; 302int[]? expected = JsonSerializer.Deserialize<int[]>(stream) as int[]; 339int[]? expected = JsonSerializer.Deserialize<int[]>(stream) as int[]; 358int[]? expected = JsonSerializer.Deserialize<int[]>(stream) as int[]; 377int[]? expected = JsonSerializer.Deserialize<int[]>(stream) as int[]; 396int[]? expected = JsonSerializer.Deserialize<int[]>(stream) as int[];
Microsoft.VisualStudio.LanguageServices (1)
ProjectSystem\SdkAnalyzerAssemblyRedirector.cs (1)
83metadata = JsonSerializer.Deserialize<Dictionary<string, MetadataEntry>>(File.ReadAllText(metadataFilePath));
Microsoft.VisualStudio.LanguageServices.CSharp.UnitTests (1)
ProjectSystemShim\SdkAnalyzerAssemblyRedirectorTests.cs (1)
124File.WriteAllText(metadataFilePath, JsonSerializer.Serialize(metadata));
OrderProcessor (1)
OrderProcessingWorker.cs (1)
66var order = JsonSerializer.Deserialize<Order>(message.Span) ?? new Order() { Id = "fake" };
RepoTasks (1)
GenerateTestDevCert.cs (1)
55JsonSerializer.Serialize(file, devCertJson);
RunTests (1)
AssemblyScheduler.cs (1)
257var deserialized = JsonSerializer.Deserialize<List<string>>(File.ReadAllText(testListPath));
Shared.Tests (2)
JsonSchemaExporter\SchemaTestHelpers.cs (2)
69JsonSchema jsonSchema = JsonSerializer.Deserialize(schema, Context.Default.JsonSchema)!; 75JsonSerializer.Serialize(node, Context.Default.JsonNode!);
System.Memory.Data (14)
System\BinaryData.cs (14)
79/// using <see cref="JsonSerializer"/>. 83/// <see cref="JsonSerializer"/>.</param> 91JsonSerializer.SerializeToUtf8Bytes(jsonSerializable, type ?? jsonSerializable?.GetType() ?? typeof(object), options), 98/// using <see cref="JsonSerializer"/> 102/// <see cref="JsonSerializer"/>.</param> 108JsonSerializer.SerializeToUtf8Bytes(jsonSerializable, type ?? jsonSerializable?.GetType() ?? typeof(object), context), 371/// the <see cref="JsonSerializer"/> 382=> new BinaryData(JsonSerializer.SerializeToUtf8Bytes(jsonSerializable, options), MediaTypeApplicationJson); 386/// the <see cref="JsonSerializer"/> 395=> new BinaryData(JsonSerializer.SerializeToUtf8Bytes(jsonSerializable, jsonTypeInfo), MediaTypeApplicationJson); 441/// <see cref="JsonSerializer"/>. 450=> JsonSerializer.Deserialize<T>(GetBytesWithTrimmedBom(), options); 454/// <see cref="JsonSerializer"/>. 461=> JsonSerializer.Deserialize(GetBytesWithTrimmedBom(), jsonTypeInfo);
System.Net.Http.Json (14)
System\Net\Http\Json\HttpClientJsonExtensions.cs (4)
20FromJsonAsyncCore(getMethod, client, requestUri, static (stream, options, cancellation) => JsonSerializer.DeserializeAsync(stream, options.type, options.options ?? JsonSerializerOptions.Web, cancellation), (type, options), cancellationToken); 25FromJsonAsyncCore(getMethod, client, requestUri, static (stream, options, cancellation) => JsonSerializer.DeserializeAsync<TValue>(stream, options ?? JsonSerializerOptions.Web, cancellation), options, cancellationToken); 28FromJsonAsyncCore(getMethod, client, requestUri, static (stream, options, cancellation) => JsonSerializer.DeserializeAsync(stream, options.type, options.context, cancellation), (type, context), cancellationToken); 31FromJsonAsyncCore(getMethod, client, requestUri, static (stream, options, cancellation) => JsonSerializer.DeserializeAsync(stream, options, cancellation), jsonTypeInfo, cancellationToken);
System\Net\Http\Json\HttpClientJsonExtensions.Get.AsyncEnumerable.cs (1)
166await foreach (TValue? value in JsonSerializer.DeserializeAsyncEnumerable<TValue>(
System\Net\Http\Json\HttpContentJsonExtensions.AsyncEnumerable.cs (1)
101await foreach (TValue? value in JsonSerializer.DeserializeAsyncEnumerable<TValue>(
System\Net\Http\Json\HttpContentJsonExtensions.cs (4)
88return await JsonSerializer.DeserializeAsync(contentStream, type, options ?? JsonSerializerOptions.Web, cancellationToken).ConfigureAwait(false); 98return await JsonSerializer.DeserializeAsync<T>(contentStream, options ?? JsonSerializerOptions.Web, cancellationToken).ConfigureAwait(false); 120return await JsonSerializer.DeserializeAsync(contentStream, type, context, cancellationToken).ConfigureAwait(false); 128return await JsonSerializer.DeserializeAsync(contentStream, jsonTypeInfo, cancellationToken).ConfigureAwait(false);
System\Net\Http\Json\JsonContent.cs (3)
119: JsonSerializer.SerializeAsync(targetStream, Value, _typeInfo, cancellationToken); 131await JsonSerializer.SerializeAsync(transcodingStream, Value, _typeInfo, cancellationToken).ConfigureAwait(false); 135JsonSerializer.Serialize(transcodingStream, Value, _typeInfo);
System\Net\Http\Json\JsonContent.netcoreapp.cs (1)
22JsonSerializer.Serialize(stream, Value, _typeInfo);
System.Private.Windows.Core (6)
System\Private\Windows\JsonData.cs (2)
120result = JsonSerializer.Deserialize<T>(JsonBytes); 156internal static IJsonData Create<T>(T data) => new JsonData<T>() { JsonBytes = JsonSerializer.SerializeToUtf8Bytes(data) };
System\Private\Windows\Nrbf\SerializationRecordExtensions.cs (1)
639@object = (T?)JsonSerializer.Deserialize(ref reader, boundType);
System\Private\Windows\Ole\Composition.cs (3)
100/// Stores the data in the specified format using the <see cref="JsonSerializer"/>. 106/// The default behavior of <see cref="JsonSerializer"/> is used to serialize the data. 112/// for more details on default <see cref="JsonSerializer"/> behavior.
System.Private.Windows.Core.Tests (1)
System\Private\Windows\Ole\NativeToManagedAdapterTests.cs (1)
105BinaryFormatWriter.TryWriteJsonData(stream, new JsonData<int[]>() { JsonBytes = JsonSerializer.SerializeToUtf8Bytes(new int[] { 0xBE, 0xAD }) });
System.Text.Json (175)
src\libraries\System.Text.Json\Common\JsonNumberHandling.cs (1)
7/// Determines how <see cref="JsonSerializer"/> handles numbers when serializing and deserializing.
src\libraries\System.Text.Json\Common\JsonSourceGenerationMode.cs (2)
23/// This mode supports all <see cref="JsonSerializer"/> features. 31/// This mode supports only a subset of <see cref="JsonSerializer"/> features.
src\libraries\System.Text.Json\Common\JsonUnmappedMemberHandling.cs (1)
7/// Determines how <see cref="JsonSerializer"/> handles JSON properties that
System\Text\Json\Nodes\JsonNode.cs (2)
372[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 373[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]
System\Text\Json\Nodes\JsonValueOfTCustomized.cs (1)
27internal override JsonNode DeepCloneCore() => JsonSerializer.SerializeToNode(Value, _jsonTypeInfo)!;
System\Text\Json\Schema\JsonSchemaExporter.cs (2)
238propertySchema.DefaultValue = JsonSerializer.SerializeToNode(parameterInfo.DefaultValue, property.JsonTypeInfo); 283const string ValuesKeyword = JsonSerializer.ValuesPropertyName;
System\Text\Json\Serialization\Attributes\JsonNumberHandlingAttribute.cs (1)
23if (!JsonSerializer.IsValidNumberHandlingValue(handling))
System\Text\Json\Serialization\Attributes\JsonObjectCreationHandlingAttribute.cs (1)
45if (!JsonSerializer.IsValidCreationHandlingValue(handling))
System\Text\Json\Serialization\Converters\CastingConverter.cs (5)
45=> JsonSerializer.UnboxOnRead<T>(_sourceConverter.ReadAsObject(ref reader, typeToConvert, options)); 53value = JsonSerializer.UnboxOnRead<T>(sourceValue); 64return JsonSerializer.UnboxOnRead<T>(_sourceConverter.ReadAsPropertyNameAsObject(ref reader, typeToConvert, options))!; 80return JsonSerializer.UnboxOnRead<T>(_sourceConverter.ReadAsPropertyNameCoreAsObject(ref reader, typeToConvert, options))!; 127=> JsonSerializer.UnboxOnRead<T>(_sourceConverter.ReadNumberWithCustomHandlingAsObject(ref reader, handling, options))!;
System\Text\Json\Serialization\Converters\Collection\IAsyncEnumerableConverterFactory.cs (1)
15[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]
System\Text\Json\Serialization\Converters\Collection\IEnumerableConverterFactory.cs (2)
18[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 25[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)]
System\Text\Json\Serialization\Converters\Collection\JsonCollectionConverter.cs (5)
146if (!JsonSerializer.TryReadMetadata(this, jsonTypeInfo, ref reader, ref state)) 154value = JsonSerializer.ResolveReferenceId<TCollection>(ref state); 177JsonSerializer.ValidateMetadataForArrayConverter(this, ref reader, ref state); 269Debug.Assert(JsonSerializer.IsMetadataPropertyName(reader.GetUnescapedSpan(), (state.Current.BaseJsonTypeInfo ?? jsonTypeInfo).PolymorphicTypeResolver), "should only be hit if metadata property."); 316state.Current.MetadataPropertyName = JsonSerializer.WriteMetadataForCollection(this, ref state, writer);
System\Text\Json\Serialization\Converters\Collection\JsonDictionaryConverter.cs (5)
168if (!JsonSerializer.TryReadMetadata(this, jsonTypeInfo, ref reader, ref state)) 176value = JsonSerializer.ResolveReferenceId<TDictionary>(ref state); 200JsonSerializer.ValidateMetadataForObjectConverter(ref state); 253if (JsonSerializer.IsMetadataPropertyName(propertyName, state.Current.BaseJsonTypeInfo.PolymorphicTypeResolver)) 358JsonSerializer.WriteMetadataForObject(this, ref state, writer);
System\Text\Json\Serialization\Converters\Collection\MemoryConverterFactory.cs (1)
10[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]
System\Text\Json\Serialization\Converters\Collection\StackOrQueueConverterWithReflection.cs (4)
15[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 16[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 19[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 20[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]
System\Text\Json\Serialization\Converters\Object\ObjectConverter.cs (2)
118JsonSerializer.TryHandleReferenceFromJsonElement(ref reader, ref state, element, out referenceValue)) 135JsonSerializer.TryHandleReferenceFromJsonNode(ref reader, ref state, node, out referenceValue))
System\Text\Json\Serialization\Converters\Object\ObjectConverterFactory.cs (2)
17[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 23[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)]
System\Text\Json\Serialization\Converters\Object\ObjectDefaultConverter.cs (10)
71if (!JsonSerializer.TryReadMetadata(this, jsonTypeInfo, ref reader, ref state)) 79value = JsonSerializer.ResolveReferenceId<T>(ref state); 102JsonSerializer.ValidateMetadataForObjectConverter(ref state); 107value = JsonSerializer.ResolveReferenceId<T>(ref state); 175ReadOnlySpan<byte> unescapedPropertyName = JsonSerializer.GetPropertyName(ref state, ref reader, options, out bool isAlreadyReadMetadataProperty); 184jsonPropertyInfo = JsonSerializer.LookupProperty( 292ReadOnlySpan<byte> unescapedPropertyName = JsonSerializer.GetPropertyName(ref state, ref reader, options, out bool isAlreadyReadMetadataProperty); 296JsonPropertyInfo jsonPropertyInfo = JsonSerializer.LookupProperty( 335JsonSerializer.WriteMetadataForObject(this, ref state, writer); 378JsonSerializer.WriteMetadataForObject(this, ref state, writer);
System\Text\Json\Serialization\Converters\Object\ObjectWithParameterizedConstructorConverter.cs (9)
106JsonSerializer.CreateExtensionDataProperty(obj, jsonPropertyInfo, options); 134if (!JsonSerializer.TryReadMetadata(this, jsonTypeInfo, ref reader, ref state)) 142value = JsonSerializer.ResolveReferenceId<T>(ref state); 180JsonSerializer.ValidateMetadataForObjectConverter(ref state); 185value = JsonSerializer.ResolveReferenceId<T>(ref state); 238JsonSerializer.CreateExtensionDataProperty(obj, jsonPropertyInfo, options); 318ReadOnlySpan<byte> unescapedPropertyName = JsonSerializer.GetPropertyName(ref state, ref reader, options, out bool isAlreadyReadMetadataProperty); 428ReadOnlySpan<byte> unescapedPropertyName = JsonSerializer.GetPropertyName(ref state, ref reader, options, out bool isAlreadyReadMetadataProperty); 623jsonPropertyInfo = JsonSerializer.LookupProperty(
System\Text\Json\Serialization\Converters\Object\ObjectWithParameterizedConstructorConverter.Large.Reflection.cs (4)
17[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 18[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 23[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 24[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]
System\Text\Json\Serialization\Converters\Object\ObjectWithParameterizedConstructorConverter.Small.cs (2)
122[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 123[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]
System\Text\Json\Serialization\Converters\Value\EnumConverterFactory.cs (1)
10[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]
System\Text\Json\Serialization\Converters\Value\NullableConverterFactory.cs (1)
11[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]
System\Text\Json\Serialization\Converters\Value\UnsupportedTypeConverterFactory.cs (1)
11[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]
System\Text\Json\Serialization\JsonConverter.cs (2)
234[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 235[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]
System\Text\Json\Serialization\JsonConverter.MetadataHandling.cs (1)
170if (canHaveIdMetadata && JsonSerializer.TryGetReferenceForValue(value, ref state, writer))
System\Text\Json\Serialization\JsonConverterOfT.cs (6)
79T valueOfT = JsonSerializer.UnboxOnWrite<T>(value)!; 86T valueOfT = JsonSerializer.UnboxOnWrite<T>(value)!; 93T valueOfT = JsonSerializer.UnboxOnWrite<T>(value)!; 99T valueOfT = JsonSerializer.UnboxOnWrite<T>(value)!; 105T valueOfT = JsonSerializer.UnboxOnWrite<T>(value)!; 112T valueOfT = JsonSerializer.UnboxOnWrite<T>(value)!;
System\Text\Json\Serialization\JsonSerializerOptions.Caching.cs (2)
51/// Returned metadata can be downcast to <see cref="JsonTypeInfo{T}"/> and used with the relevant <see cref="JsonSerializer"/> overloads. 76/// Returned metadata can be downcast to <see cref="JsonTypeInfo{T}"/> and used with the relevant <see cref="JsonSerializer"/> overloads.
System\Text\Json\Serialization\JsonSerializerOptions.Converters.cs (2)
13/// Provides options to be used with <see cref="JsonSerializer"/>. 45if (JsonSerializer.IsReflectionEnabledByDefault)
System\Text\Json\Serialization\JsonSerializerOptions.cs (20)
19/// Provides options to be used with <see cref="JsonSerializer"/>. 40[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 41[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 55[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 56[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 70[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 71[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 231/// The property will be populated automatically once used with one of the <see cref="JsonSerializer"/> methods. 461if (!JsonSerializer.IsValidNumberHandlingValue(value)) 487if (!JsonSerializer.IsValidCreationHandlingValue(value)) 679/// Determines how <see cref="JsonSerializer"/> handles JSON properties that 899/// it has been passed to one of the <see cref="JsonSerializer"/> methods, 930/// The <see cref="JsonSerializer.IsReflectionEnabledByDefault"/> feature switch has been turned off. 934/// the semantics of the <see cref="JsonSerializer"/> methods accepting <see cref="JsonSerializerOptions"/> parameters. 960[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 961[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 964if (JsonSerializer.IsReflectionEnabledByDefault) 1166[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 1167[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 1178TypeInfoResolver = JsonSerializer.IsReflectionEnabledByDefault
System\Text\Json\Serialization\Metadata\DefaultJsonTypeInfoResolver.Converters.cs (10)
18[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 19[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 92[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 93[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 131[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 132[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 142[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 143[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 173[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 174[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]
System\Text\Json\Serialization\Metadata\DefaultJsonTypeInfoResolver.cs (8)
23[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 24[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 29[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 30[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 77[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 78[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 122[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 123[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]
System\Text\Json\Serialization\Metadata\DefaultJsonTypeInfoResolver.Helpers.cs (24)
18[RequiresUnreferencedCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 19[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 44[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 45[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 94[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 95[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 138[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 139[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 198[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 199[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 220[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 221[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 284[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 285[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 320[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 321[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 408[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 409[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 449[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 450[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 468[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 469[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 492[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 493[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]
System\Text\Json\Serialization\Metadata\JsonPolymorphismOptions.cs (1)
76get => _typeDiscriminatorPropertyName ?? JsonSerializer.TypePropertyName;
System\Text\Json\Serialization\Metadata\JsonPropertyInfo.cs (5)
211if (!JsonSerializer.IsValidCreationHandlingValue(value.Value)) 471[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 472[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 481Name is JsonSerializer.IdPropertyName or JsonSerializer.RefPropertyName)
System\Text\Json\Serialization\Metadata\JsonPropertyInfoOfT.cs (2)
142[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 143[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]
System\Text\Json\Serialization\Metadata\JsonTypeInfo.cs (6)
337/// it has been passed to one of the <see cref="JsonSerializer"/> methods, 507if (value is not null && !JsonSerializer.IsValidNumberHandlingValue(value.Value)) 548if (value is not null && !JsonSerializer.IsValidUnmappedMemberHandlingValue(value.Value)) 592if (value is not null && !JsonSerializer.IsValidCreationHandlingValue(value.Value)) 1003[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 1004[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)]
System\Text\Json\Serialization\Metadata\JsonTypeInfoOfT.WriteHelpers.cs (8)
70int flushThreshold = (int)(writer.Capacity * JsonSerializer.FlushThreshold); 80int flushThreshold = (int)(4 * PipeOptions.Default.MinimumSegmentSize * JsonSerializer.FlushThreshold); 311state.FlushThreshold = (int)(bufferWriter.Capacity * JsonSerializer.FlushThreshold); 341=> Serialize(writer, JsonSerializer.UnboxOnWrite<T>(rootValue), rootValue); 344=> SerializeAsync(pipeWriter, JsonSerializer.UnboxOnWrite<T>(rootValue), flushThreshold, cancellationToken, rootValue); 347=> SerializeAsync(utf8Json, JsonSerializer.UnboxOnWrite<T>(rootValue), cancellationToken, rootValue); 350=> SerializeAsync(utf8Json, JsonSerializer.UnboxOnWrite<T>(rootValue), cancellationToken, rootValue); 353=> Serialize(utf8Json, JsonSerializer.UnboxOnWrite<T>(rootValue), rootValue);
System\Text\Json\Serialization\Metadata\PolymorphicTypeResolver.cs (2)
81if (!propertyName.Equals(JsonSerializer.TypePropertyName, StringComparison.Ordinal)) 86if ((JsonSerializer.GetMetadataPropertyName(utf8EncodedName, resolver: null) & ~MetadataPropertyName.Type) != 0)
System\Text\Json\Serialization\Metadata\ReflectionEmitCachingMemberAccessor.cs (2)
16[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 17[RequiresUnreferencedCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]
System\Text\Json\Serialization\Metadata\ReflectionEmitMemberAccessor.cs (2)
13[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 14[RequiresUnreferencedCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]
System\Text\Json\Serialization\Metadata\ReflectionMemberAccessor.cs (2)
11[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 12[RequiresUnreferencedCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]
System\Text\Json\Serialization\ReferenceHandler.cs (1)
9/// This class defines how the <see cref="JsonSerializer"/> deals with references on serialization and deserialization.
System\Text\Json\Serialization\ReferenceHandlerOfT.cs (1)
7/// This class defines how the <see cref="JsonSerializer"/> deals with references on serialization and deserialization.
System\Text\Json\Serialization\ReferenceResolver.cs (1)
7/// This class defines how the <see cref="JsonSerializer"/> deals with references on serialization and deserialization.
System\Text\Json\ThrowHelper.Serialization.cs (1)
841MetadataPropertyName name = JsonSerializer.GetMetadataPropertyName(propertyName, state.Current.BaseJsonTypeInfo.PolymorphicTypeResolver);
System.Windows.Forms.Tests (9)
System\Windows\Forms\BinaryFormat\WinFormsBinaryFormattedObjectTests.cs (3)
43JsonBytes = JsonSerializer.SerializeToUtf8Bytes(testData) 70JsonBytes = JsonSerializer.SerializeToUtf8Bytes(testData) 98result = JsonSerializer.Deserialize<SimpleTestData>(JsonBytes);
System\Windows\Forms\ClipboardTests.cs (6)
966JsonSerializer.Deserialize(byteData.GetArray(), typeof(SimpleTestData)).Should().BeEquivalentTo(testData); 978byte[] serialized = JsonSerializer.SerializeToUtf8Bytes(font); 979Action a1 = () => JsonSerializer.Deserialize<Font>(serialized); 1015JsonSerializer.Deserialize(jsonBytes, typeof(SimpleTestData)).Should().BeEquivalentTo(data); 1043return JsonSerializer.Deserialize<T>(_formatToJson[format]); 1058_formatToJson.Add(format, JsonSerializer.SerializeToUtf8Bytes(data));
Templates.Blazor.Tests (2)
BlazorWasmTemplateTest.cs (1)
122var serviceWorkerAssetsManifestVersion = JsonSerializer.Deserialize<string>(serviceWorkerAssetsManifestVersionJson);
src\ProjectTemplates\Shared\DevelopmentCertificate.cs (1)
27var certificateAttributes = JsonSerializer.Deserialize<CertificateAttributes>(file) ??
Templates.Blazor.WebAssembly.Auth.Tests (1)
src\ProjectTemplates\Shared\DevelopmentCertificate.cs (1)
27var certificateAttributes = JsonSerializer.Deserialize<CertificateAttributes>(file) ??
Templates.Blazor.WebAssembly.Tests (1)
src\ProjectTemplates\Shared\DevelopmentCertificate.cs (1)
27var certificateAttributes = JsonSerializer.Deserialize<CertificateAttributes>(file) ??
Templates.Mvc.Tests (1)
src\ProjectTemplates\Shared\DevelopmentCertificate.cs (1)
27var certificateAttributes = JsonSerializer.Deserialize<CertificateAttributes>(file) ??
Templates.Tests (1)
src\ProjectTemplates\Shared\DevelopmentCertificate.cs (1)
27var certificateAttributes = JsonSerializer.Deserialize<CertificateAttributes>(file) ??
TestDiscoveryWorker (1)
Program.cs (1)
95await JsonSerializer.SerializeAsync(fileStream, testsToWrite.OrderBy(x => x)).ConfigureAwait(false);
TestProject.AppHost (1)
TestProgram.cs (1)
199await Console.Out.WriteLineAsync("$ENDPOINTS: " + JsonSerializer.Serialize(root, JsonSerializerOptions.Default));
Wasm.Performance.Driver (2)
BenchmarkResultsStartup.cs (1)
22var result = await JsonSerializer.DeserializeAsync<BenchmarkResult>(context.Request.Body, new JsonSerializerOptions
Program.cs (1)
258builder.AppendLine(JsonSerializer.Serialize(output));
Wasm.Performance.TestApp (7)
Json_razor.g.cs (7)
279smallOrgChartJson = JsonSerializer.Serialize(smallOrgChart); 280largeOrgChartJson = JsonSerializer.Serialize(largeOrgChart); 297=> serializedValue = JsonSerializer.Serialize(smallOrgChart); 300=> serializedValue = JsonSerializer.Serialize(largeOrgChart); 303=> serializedValue = JsonSerializer.Serialize(largeOrgChart, personJsonContext.Person); 312=> numPeopleDeserialized = CountPeople(JsonSerializer.Deserialize<Person>(largeOrgChartJson, personJsonContext.Person)); 316var ceo = JsonSerializer.Deserialize<Person>(json);