JsonSerializer

Agents\ClaudeCode\ClaudeCodeAgentEnvironmentScanner.cs (1)

234var jsonContent = JsonSerializer.Serialize(config, JsonSourceGenerationContext.Default.JsonObject);

Agents\CopilotCli\CopilotCliAgentEnvironmentScanner.cs (1)

236var jsonContent = JsonSerializer.Serialize(config, JsonSourceGenerationContext.Default.JsonObject);

Agents\DeprecatedMcpCommandScanner.cs (1)

213var jsonContent = JsonSerializer.Serialize(config, JsonSourceGenerationContext.Default.JsonObject);

Agents\OpenCode\OpenCodeAgentEnvironmentScanner.cs (1)

225var jsonOutput = JsonSerializer.Serialize(config, JsonSourceGenerationContext.Default.JsonObject);

Agents\VsCode\VsCodeAgentEnvironmentScanner.cs (1)

275var jsonContent = JsonSerializer.Serialize(config, JsonSourceGenerationContext.Default.JsonObject);

Commands\AgentMcpCommand.cs (1)

228_logger.LogDebug("Invoking tool {Name} with arguments {Arguments}", toolName, JsonSerializer.Serialize(args, BackchannelJsonSerializerContext.Default.DictionaryStringJsonElement));

Commands\AppHostLauncher.cs (1)

341var json = JsonSerializer.Serialize(jsonResult, RunCommandJsonContext.RelaxedEscaping.DetachOutputInfo);

Commands\ConfigCommand.cs (1)

475var json = System.Text.Json.JsonSerializer.Serialize(info, JsonSourceGenerationContext.Default.ConfigInfo);

Commands\DescribeCommand.cs (2)

182var json = JsonSerializer.Serialize(output, ResourcesCommandJsonContext.RelaxedEscaping.ResourcesOutput); 232var json = JsonSerializer.Serialize(resourceJson, ResourcesCommandJsonContext.Ndjson.ResourceJson);

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)

83var json = System.Text.Json.JsonSerializer.Serialize(response, JsonSourceGenerationContext.RelaxedEscaping.DoctorCheckResponse);

Commands\ExportCommand.cs (2)

267var apiResponse = JsonSerializer.Deserialize(json, OtlpJsonSerializerContext.Default.TelemetryApiResponse); 298var apiResponse = JsonSerializer.Deserialize(json, OtlpJsonSerializerContext.Default.TelemetryApiResponse);

Commands\ExtensionInternalCommand.cs (1)

46var json = JsonSerializer.Serialize(new AppHostProjectSearchResultPoco

Commands\LogsCommand.cs (2)

233var json = JsonSerializer.Serialize(logsOutput, LogsCommandJsonContext.Snapshot.LogsOutput); 333var output = JsonSerializer.Serialize(logLineJson, LogsCommandJsonContext.Ndjson.LogLineJson);

Commands\PsCommand.cs (1)

137var json = JsonSerializer.Serialize(appHostInfos, PsCommandJsonContext.RelaxedEscaping.ListAppHostDisplayInfo);

Commands\Sdk\SdkDumpCommand.cs (1)

267return JsonSerializer.Serialize(capabilities, CapabilitiesJsonContext.Default.CapabilitiesInfo);

Commands\TelemetryLogsCommand.cs (2)

226var response = JsonSerializer.Deserialize(json, OtlpJsonSerializerContext.Default.TelemetryApiResponse); 240var request = JsonSerializer.Deserialize(json, OtlpJsonSerializerContext.Default.OtlpExportLogsServiceRequestJson);

Commands\TelemetrySpansCommand.cs (2)

227var response = JsonSerializer.Deserialize(json, OtlpJsonSerializerContext.Default.TelemetryApiResponse); 241var request = JsonSerializer.Deserialize(json, OtlpJsonSerializerContext.Default.OtlpExportTraceServiceRequestJson);

Commands\TelemetryTracesCommand.cs (2)

241var response = JsonSerializer.Deserialize(json, OtlpJsonSerializerContext.Default.TelemetryApiResponse); 314var response = JsonSerializer.Deserialize(json, OtlpJsonSerializerContext.Default.TelemetryApiResponse);

Configuration\AspireConfigFile.cs (2)

127return JsonSerializer.Deserialize(json, JsonSourceGenerationContext.Default.AspireConfigFile) 146var json = JsonSerializer.Serialize(this, JsonSourceGenerationContext.RelaxedEscaping.AspireConfigFile);

Configuration\AspireJsonConfiguration.cs (2)

112return JsonSerializer.Deserialize(json, JsonSourceGenerationContext.Default.AspireJsonConfiguration); 139var json = JsonSerializer.Serialize(this, JsonSourceGenerationContext.Default.AspireJsonConfiguration);

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)

88var resourceGraphData = JsonSerializer.Serialize(resources.ToArray(), ListResourcesToolJsonContext.RelaxedEscaping.ResourceJsonArray);

NuGet\BundleNuGetPackageCache.cs (1)

194var result = JsonSerializer.Deserialize(output, BundleSearchJsonContext.Default.BundleSearchResult);

Program.cs (1)

170var legacyConfig = JsonSerializer.Deserialize(legacyJson, JsonSourceGenerationContext.Default.AspireJsonConfiguration);

src\Shared\Export\ExportArchive.cs (4)

86JsonSerializer.Serialize(writer, resource, s_serializerContext.ResourceJson); 106JsonSerializer.Serialize(writer, data, s_serializerContext.OtlpTelemetryDataJson); 114JsonSerializer.Serialize(writer, data, s_serializerContext.OtlpTelemetryDataJson); 122JsonSerializer.Serialize(writer, data, s_serializerContext.OtlpTelemetryDataJson);

Utils\ConfigurationHelper.cs (2)

77var jsonContent = JsonSerializer.Serialize(settings, JsonSourceGenerationContext.Default.JsonObject); 88var jsonContent = JsonSerializer.Serialize(settings, JsonSourceGenerationContext.Default.JsonObject);

Utils\EnvironmentChecker\ContainerRuntimeCheck.cs (1)

514var json = JsonSerializer.Deserialize(output, JsonSourceGenerationContext.Default.ContainerVersionJson);

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\DescribeCommandTests.cs (7)

201.Select(r => JsonSerializer.Serialize(r, ResourcesCommandJsonContext.Ndjson.ResourceJson)) 212var deserialized = JsonSerializer.Deserialize(line, ResourcesCommandJsonContext.Ndjson.ResourceJson); 219.Select(line => JsonSerializer.Deserialize(line, ResourcesCommandJsonContext.Ndjson.ResourceJson)) 242var json = JsonSerializer.Serialize(resourcesOutput, ResourcesCommandJsonContext.RelaxedEscaping.ResourcesOutput); 250var deserialized = JsonSerializer.Deserialize(json, ResourcesCommandJsonContext.RelaxedEscaping.ResourcesOutput); 287var first = JsonSerializer.Deserialize(jsonLines[0], ResourcesCommandJsonContext.Ndjson.ResourceJson); 293var second = JsonSerializer.Deserialize(jsonLines[1], ResourcesCommandJsonContext.Ndjson.ResourceJson);

Commands\ExportCommandTests.cs (16)

Commands\ExtensionInternalCommandTests.cs (2)

83searchResult = JsonSerializer.Deserialize(allOutput, BackchannelJsonSerializerContext.Default.AppHostProjectSearchResultPoco); 125searchResult = JsonSerializer.Deserialize(allOutput, BackchannelJsonSerializerContext.Default.AppHostProjectSearchResultPoco);

Commands\LogsCommandTests.cs (17)

Commands\PsCommandTests.cs (3)

149var appHosts = JsonSerializer.Deserialize(jsonOutput, PsCommandJsonContext.RelaxedEscaping.ListAppHostDisplayInfo); 254var appHosts = JsonSerializer.Deserialize(jsonOutput, PsCommandJsonContext.RelaxedEscaping.ListAppHostDisplayInfo); 316var appHosts = JsonSerializer.Deserialize(jsonOutput, PsCommandJsonContext.RelaxedEscaping.ListAppHostDisplayInfo);

Commands\TelemetryLogsCommandTests.cs (1)

146return JsonSerializer.Serialize(response, OtlpJsonSerializerContext.Default.TelemetryApiResponse);

Commands\TelemetrySpansCommandTests.cs (1)

148return JsonSerializer.Serialize(response, OtlpJsonSerializerContext.Default.TelemetryApiResponse);

Commands\TelemetryTestHelper.cs (1)

68var resourcesJson = JsonSerializer.Serialize(resources, OtlpJsonSerializerContext.Default.ResourceInfoJsonArray);

Commands\TelemetryTracesCommandTests.cs (1)

196return JsonSerializer.Serialize(response, OtlpJsonSerializerContext.Default.TelemetryApiResponse);

Mcp\ListStructuredLogsToolTests.cs (6)

142var apiResponse = JsonSerializer.Serialize(apiResponseObj, OtlpJsonSerializerContext.Default.TelemetryApiResponse); 151var resourcesResponse = JsonSerializer.Serialize(resources, OtlpJsonSerializerContext.Default.ResourceInfoJsonArray); 248var apiResponse = JsonSerializer.Serialize(apiResponseObj, OtlpJsonSerializerContext.Default.TelemetryApiResponse); 254var resourcesResponse = JsonSerializer.Serialize(resources, OtlpJsonSerializerContext.Default.ResourceInfoJsonArray); 301var resourcesResponse = JsonSerializer.Serialize(resources, OtlpJsonSerializerContext.Default.ResourceInfoJsonArray); 309var emptyLogsJson = JsonSerializer.Serialize(emptyLogsResponse, OtlpJsonSerializerContext.Default.TelemetryApiResponse);

Mcp\ListTracesToolTests.cs (8)

Projects\FallbackProjectParserTests.cs (1)

17return JsonSerializer.Serialize(document.RootElement, s_indentedOptions);

Projects\ProjectLocatorTests.cs (7)

66await JsonSerializer.SerializeAsync(writer, new 100await JsonSerializer.SerializeAsync(writer, new 128await JsonSerializer.SerializeAsync(writer, new 172await JsonSerializer.SerializeAsync(writer, new 311var settings = JsonSerializer.Deserialize<AspireConfigFile>(settingsJson); 343await File.WriteAllTextAsync(aspireSettingsFile.FullName, JsonSerializer.Serialize(new { appHostPath = relativeAppHostPath })); 365var migratedConfig = JsonSerializer.Deserialize<AspireConfigFile>(configJson);

MetricsService.cs (1)

26statistics = JsonSerializer.Deserialize(json, StatisticsJsonSerializerContext.Default.Statistics);

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(

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\GenAIMessageParsingHelper.cs (1)

84return JsonSerializer.Deserialize(ref reader, GenAIMessagesContext.Default.MessagePart);

Model\GenAI\GenAIMessages.cs (1)

262JsonSerializer.Serialize(writer, (object)value, value.GetType(), options);

Model\GenAI\GenAIVisualizerDialogViewModel.cs (1)

566return JsonSerializer.Deserialize<TValue>(json, jsonTypeInfo)!;

Model\TelemetryExportService.cs (4)

330return JsonSerializer.Serialize(data, options); 359return JsonSerializer.Serialize(data, OtlpJsonSerializerContext.IndentedOptions); 382return JsonSerializer.Serialize(data, OtlpJsonSerializerContext.IndentedOptions); 692return 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)

20var jsonObj = JsonSerializer.Deserialize(json, OtlpJsonSerializerContext.Default.OtlpExportTraceServiceRequestJson); 25var jsonObj = JsonSerializer.Deserialize(json, OtlpJsonSerializerContext.Default.OtlpExportLogsServiceRequestJson); 30var jsonObj = JsonSerializer.Deserialize(json, OtlpJsonSerializerContext.Default.OtlpExportMetricsServiceRequestJson); 40return JsonSerializer.Serialize(json, OtlpJsonSerializerContext.Default.OtlpExportTraceServiceResponseJson); 45return JsonSerializer.Serialize(json, OtlpJsonSerializerContext.Default.OtlpExportLogsServiceResponseJson); 50return JsonSerializer.Serialize(json, OtlpJsonSerializerContext.Default.OtlpExportMetricsServiceResponseJson);

src\Shared\Export\ExportArchive.cs (4)

86JsonSerializer.Serialize(writer, resource, s_serializerContext.ResourceJson); 106JsonSerializer.Serialize(writer, data, s_serializerContext.OtlpTelemetryDataJson); 114JsonSerializer.Serialize(writer, data, s_serializerContext.OtlpTelemetryDataJson); 122JsonSerializer.Serialize(writer, data, s_serializerContext.OtlpTelemetryDataJson);

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>

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 (18)

Model\TelemetryExportServiceTests.cs (12)

Model\TelemetryImportServiceTests.cs (6)

293var jsonString = JsonSerializer.Serialize(exportedJson, OtlpJsonSerializerContext.DefaultOptions); 350var jsonString = JsonSerializer.Serialize(exportedJson, OtlpJsonSerializerContext.DefaultOptions); 405var jsonString = JsonSerializer.Serialize(exportedJson, OtlpJsonSerializerContext.DefaultOptions); 463return JsonSerializer.Serialize(telemetryData, OtlpJsonSerializerContext.IndentedOptions); 511return JsonSerializer.Serialize(telemetryData, OtlpJsonSerializerContext.IndentedOptions); 563return 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);

tests\Shared\TemplatesTesting\ProjectInfo.cs (1)

60JsonSerializer.Deserialize<Dictionary<string, ProjectInfo>>(json)!;

ApplicationModel\Docker\DockerfileStatements.cs (2)

169var commandJson = JsonSerializer.Serialize(_command, options); 240var commandJson = JsonSerializer.Serialize(_command, options);

Backchannel\AuxiliaryBackchannelRpcTarget.cs (2)

797logger.LogDebug("Invoking tool {Name} with arguments {Arguments}", toolName, JsonSerializer.Serialize(arguments)); 804logger.LogDebug("Result: {Result}", JsonSerializer.Serialize(result));

Dashboard\DashboardEventHandlers.cs (2)

232File.WriteAllText(customConfigPath, JsonSerializer.Serialize(defaultConfig, new JsonSerializerOptions { WriteIndented = true })); 844logMessage = JsonSerializer.Deserialize(content, DashboardLogMessageContext.Default.DashboardLogMessage);

Dcp\DcpDependencyCheck.cs (1)

102var dcpInfo = JsonSerializer.Deserialize<DcpInfo>(output);

Dcp\DcpExecutor.cs (4)

558var serviceProducerAnnotations = JsonSerializer.Deserialize<ServiceProducerAnnotation[]>(servicesProducedAnnotationJson); 2550var current = JsonSerializer.SerializeToNode(obj); 2552var copy = JsonSerializer.Deserialize<T>(current)!; 2555var 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);

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)

AcrLoginService.cs (1)

124var tokenResponse = JsonSerializer.Deserialize<AcrRefreshTokenResponse>(responseBody, s_jsonOptions);

AzureBicepResource.cs (1)

254JsonSerializer.Serialize(context.Writer, inputValue);

src\Shared\LaunchProfiles\LaunchProfileExtensions.cs (1)

116var settings = JsonSerializer.Deserialize(stream, LaunchSettingsSerializerContext.Default.LaunchSettings);

AzureServiceBusRule.cs (1)

140JsonSerializer.Serialize(writer, rule.CorrelationFilter.Properties);

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

DevTunnelCliClient.cs (1)

303var result = JsonSerializer.Deserialize<T>(output, _jsonOptions);

DockerComposeServiceResource.cs (1)

437var serviceInfo = JsonSerializer.Deserialize(line, DockerComposeJsonContext.Default.DockerComposeServiceInfo);

HostedAgent\HostedAgentBuilderExtension.cs (1)

187var formattedResponse = $"```\n{JsonSerializer.Serialize(response, new JsonSerializerOptions { WriteIndented = true })}\n```";

GitHubModelsHealthCheck.cs (2)

52var jsonPayload = JsonSerializer.Serialize(payload); 79errorResponse = JsonSerializer.Deserialize<GitHubErrorResponse>(content);

JavaScriptHostingExtensions.cs (1)

1090&& JsonSerializer.Deserialize<DebugSessionCapabilities>(debugSessionInfoJson) is { } info

OpenAIModelHealthCheck.cs (1)

71errorResponse = JsonSerializer.Deserialize<OpenAIErrorResponse>(content);

AddPythonAppTests.cs (4)

1394builder.Configuration["DEBUG_SESSION_INFO"] = JsonSerializer.Serialize(runSessionInfo); 1432builder.Configuration["DEBUG_SESSION_INFO"] = JsonSerializer.Serialize(runSessionInfo); 1472builder.Configuration["DEBUG_SESSION_INFO"] = JsonSerializer.Serialize(runSessionInfo); 1509builder.Configuration["DEBUG_SESSION_INFO"] = JsonSerializer.Serialize(runSessionInfo);

Ats\AtsMarshaller.cs (3)

189var json = JsonSerializer.Serialize(value, s_jsonOptions); 470return JsonSerializer.Deserialize(jsonObj.ToJsonString(), targetType, s_jsonOptions); 564return JsonSerializer.Deserialize(value.ToJsonString(), targetType, s_jsonOptions);

Ats\CapabilityDispatcher.cs (1)

675return JsonSerializer.Deserialize<T>(obj.ToJsonString(), AtsMarshaller.JsonOptions);

DistributedApplicationFactory.cs (1)

361var settings = JsonSerializer.Deserialize(stream, LaunchSettingsSerializerContext.Default.LaunchSettings);

Dashboard\DashboardLifecycleHookTests.cs (7)

310File.WriteAllText(runtimeConfig, JsonSerializer.Serialize(originalConfig, new JsonSerializerOptions { WriteIndented = true })); 340var customConfig = JsonSerializer.Deserialize<JsonElement>(customConfigContent); 393File.WriteAllText(runtimeConfig, JsonSerializer.Serialize(originalConfig, new JsonSerializerOptions { WriteIndented = true })); 462File.WriteAllText(runtimeConfig, JsonSerializer.Serialize(originalConfig, new JsonSerializerOptions { WriteIndented = true })); 529File.WriteAllText(runtimeConfig, JsonSerializer.Serialize(originalConfig, new JsonSerializerOptions { WriteIndented = true })); 611var messageJson = JsonSerializer.Serialize(message, DashboardLogMessageContext.Default.DashboardLogMessage); 638messageJson = JsonSerializer.Serialize(message, DashboardLogMessageContext.Default.DashboardLogMessage);

Dashboard\DashboardResourceTests.cs (1)

620logger.Log(logLevel, 0, JsonSerializer.Serialize(dashboardLogMessage), null, (s, _) => s);

Dcp\DcpExecutorTests.cs (11)

Dcp\TestKubernetesService.cs (2)

63var serialized = JsonSerializer.Serialize(r); 64var clone = JsonSerializer.Deserialize<T>(serialized);

LaunchSettingsSerializerContextTests.cs (1)

33JsonSerializer.Deserialize(launchSettingsJson, LaunchSettingsSerializerContext.Default.LaunchSettings);

YarpJsonConfigGeneratorBuilder.cs (3)

88var content = JsonSerializer.Serialize(jsonObject, _serializerOptions); 100var node = JsonSerializer.SerializeToNode(route, _serializerOptions); 114var node = JsonSerializer.SerializeToNode(cluster, _serializerOptions);

tests\Shared\TemplatesTesting\ProjectInfo.cs (1)

60JsonSerializer.Deserialize<Dictionary<string, ProjectInfo>>(json)!;

NuGet\Commands\SearchCommand.cs (1)

288Console.WriteLine(JsonSerializer.Serialize(result, SearchJsonContext.Default.SearchResult));

Program.cs (1)

149var hotels = await JsonSerializer.DeserializeAsync<List<Hotel>>(openStream, cancellationToken: cancellationToken);

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

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"])!);

DataDescriptorModel.cs (1)

90return JsonSerializer.Serialize(this, s_jsonSerializerOptions);

JsonConverter\GlobalModelJsonConverter.cs (2)

21JsonSerializer.Serialize(writer, value.Value, options); 27JsonSerializer.Serialize(writer, value.Value, options);

JsonConverter\TypeModelJsonConverter.cs (1)

28JsonSerializer.Serialize(writer, field, options);

Program.cs (2)

67await database.ListRightPushAsync("entries", JsonSerializer.SerializeToUtf8Bytes(entry)); 74entries.Add(JsonSerializer.Deserialize<Entry>((string)item!)!);

ConfigSchemaEmitter.cs (1)

48return JsonSerializer.Serialize(root, s_serializerOptions);

_generated\121\PackInfoJsonSerializerContext.PackInfo.g.cs (2)

192global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Microsoft.NET.Sdk.WorkloadManifestReader.WorkloadResolver.PackInfo)value).Id, WorkloadPackId); 195global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Microsoft.NET.Sdk.WorkloadManifestReader.WorkloadResolver.PackInfo)value).Kind, WorkloadPackKind);

_generated\141\SdkVulnerabilityJsonContext.SdkVulnerabilityInfo.g.cs (1)

192global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Microsoft.DotNet.Cli.SdkVulnerability.SdkVulnerabilityInfo)value).EolDate, NullableDateTime);

_generated\156\TelemetryDiskLoggerJsonSerializerContext.ActivityModel.g.cs (1)

223global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Microsoft.DotNet.Cli.Telemetry.TelemetryDiskLogger.ActivityModel)value).duration, TimeSpan);

_generated\157\TelemetryDiskLoggerJsonSerializerContext.EventModel.g.cs (1)

135global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Microsoft.DotNet.Cli.Telemetry.TelemetryDiskLogger.EventModel)value).tags, DictionaryStringObject);

_generated\160\TelemetryDiskLoggerJsonSerializerContext.SourceModel.g.cs (1)

133global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Microsoft.DotNet.Cli.Telemetry.TelemetryDiskLogger.SourceModel)value).tags, DictionaryStringObject);

_generated\179\SdkVulnerabilityCacheJsonContext.SdkVulnerabilityCacheSummary.g.cs (1)

190global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Microsoft.DotNet.Cli.SdkVulnerabilityCacheSummary)value).EolDate, NullableDateTime);

_generated\2\CliSchemaJsonSerializerContext.ArityDetails.g.cs (1)

110global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Microsoft.DotNet.Cli.CliSchema.ArityDetails)value).maximum, NullableInt32);

_generated\39\RunFileJsonSerializerContext.RunFileArtifactsMetadata.g.cs (1)

89global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Microsoft.DotNet.Cli.Commands.Clean.FileBasedAppArtifacts.RunFileArtifactsMetadata)value).LastAutomaticCleanupUtc, NullableDateTime);

_generated\41\RunFileJsonSerializerContext.RunFileBuildCacheEntry.g.cs (1)

283global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Microsoft.DotNet.Cli.Commands.Run.RunFileBuildCacheEntry)value).BuildLevel, BuildLevel);

_generated\6\CliSchemaJsonSerializerContext.DictionaryStringArgumentDetails.g.cs (1)

60global::System.Text.Json.JsonSerializer.Serialize(writer, entry.Value, ArgumentDetails);

_generated\8\CliSchemaJsonSerializerContext.DictionaryStringOptionDetails.g.cs (1)

60global::System.Text.Json.JsonSerializer.Serialize(writer, entry.Value, OptionDetails);

_generated\86\InstallStateJsonSerializerContext.InstallStateContents.g.cs (1)

132global::System.Text.Json.JsonSerializer.Serialize(writer, __value_UseWorkloadSets, NullableBoolean);

CliSchema.cs (1)

84var result = JsonSerializer.Serialize(transportStructure, s_jsonContext.RootCommandDetails);

Commands\Clean\FileBasedAppArtifacts\CleanFileBasedAppArtifactsCommand.cs (2)

113JsonSerializer.Serialize(metadataFileStream, metadata, RunFileJsonSerializerContext.Default.RunFileArtifactsMetadata); 163var metadata = JsonSerializer.Deserialize(stream, RunFileJsonSerializerContext.Default.RunFileArtifactsMetadata);

Commands\Run\Api\RunApiCommand.cs (2)

33RunApiInput input = JsonSerializer.Deserialize(line, RunFileApiJsonSerializerContext.Default.RunApiInput)!; 47string json = JsonSerializer.Serialize(message, RunFileApiJsonSerializerContext.Default.RunApiOutput);

Commands\Run\CSharpCompilerCommand.Generated.cs (4)

73"tfm": {{JsonSerializer.Serialize(TargetFramework, CSharpCompilerCommandJsonSerializerContext.Default.String)}}, 76"version": {{JsonSerializer.Serialize(DefaultRuntimeVersion, CSharpCompilerCommandJsonSerializerContext.Default.String)}} 79"EntryPointFilePath": {{JsonSerializer.Serialize(EntryPointFileFullPath, CSharpCompilerCommandJsonSerializerContext.Default.String)}}, 80"EntryPointFileDirectoryPath": {{JsonSerializer.Serialize(BaseDirectory, CSharpCompilerCommandJsonSerializerContext.Default.String)}},

Commands\Run\VirtualProjectBuildingCommand.cs (2)

1022return JsonSerializer.Deserialize(stream, RunFileJsonSerializerContext.Default.RunFileBuildCacheEntry); 1172JsonSerializer.Serialize(stream, cache.CurrentEntry, RunFileJsonSerializerContext.Default.RunFileBuildCacheEntry);

Commands\Sdk\Check\SdkCheckCommand.cs (1)

35_sdkCheckConfig = File.Exists(configFilePath) ? JsonSerializer.Deserialize(File.ReadAllText(configFilePath), SdkCheckJsonSerializerContext.Default.SdkCheckConfig) : null;

Commands\Tool\List\ToolListGlobalOrToolPathCommand.cs (1)

126var jsonText = System.Text.Json.JsonSerializer.Serialize(jsonData, JsonHelper.JsonContext.VersionedDataContractToolListJsonContractArray);

Commands\Tool\List\ToolListLocalCommand.cs (1)

92var jsonText = System.Text.Json.JsonSerializer.Serialize(jsonData, JsonHelper.JsonContext.VersionedDataContractLocalToolListJsonContractArray);

Commands\Workload\GlobalJsonWorkloadSetFile.cs (4)

26globalJsonWorkloadSetVersions = JsonSerializer.Deserialize(fileStream, GlobalJsonWorkloadSetsJsonSerializerContext.Default.DictionaryStringString); 34JsonSerializer.Serialize(fileStream, globalJsonWorkloadSetVersions, GlobalJsonWorkloadSetsJsonSerializerContext.Default.DictionaryStringString); 64var globalJsonWorkloadSetVersions = JsonSerializer.Deserialize(fileStream, GlobalJsonWorkloadSetsJsonSerializerContext.Default.DictionaryStringString); 84JsonSerializer.Serialize(fileStream, globalJsonWorkloadSetVersions, GlobalJsonWorkloadSetsJsonSerializerContext.Default.DictionaryStringString);

Commands\Workload\Install\FileBasedInstaller.cs (3)

545var packToDelete = JsonSerializer.Deserialize(jsonPackInfo, PackInfoJsonSerializerContext.Default.PackInfo); 637File.WriteAllText(logFile, JsonSerializer.Serialize(workloadHistoryRecord, WorkloadHistoryJsonSerializerContext.Default.WorkloadHistoryRecord)); 880File.WriteAllText(path, JsonSerializer.Serialize(packInfo, PackInfoJsonSerializerContext.Default.PackInfo));

Commands\Workload\Install\WorkloadInstallCommand.cs (1)

145Reporter.WriteLine(JsonSerializer.Serialize(packageUrls, WorkloadInstallJsonSerializerContext.Default.IEnumerableString));

Commands\Workload\Install\WorkloadManifestUpdater.cs (2)

151var jsonContent = JsonSerializer.Serialize(updatableWorkloads.Select(workload => workload.ToString()).ToArray(), WorkloadManifestUpdaterJsonSerializerContext.Default.StringArray); 177var updatableWorkloads = JsonSerializer.Deserialize(File.ReadAllText(adUpdatesFile), WorkloadManifestUpdaterJsonSerializerContext.Default.StringArray);

Commands\Workload\InstallStateContents.cs (2)

26return JsonSerializer.Deserialize(contents, InstallStateJsonSerializerContext.Default.InstallStateContents) ?? new InstallStateContents(); 36return JsonSerializer.Serialize(this, InstallStateJsonSerializerContext.Default.InstallStateContents);

Commands\Workload\List\WorkloadListCommand.cs (1)

76Reporter.WriteLine(JsonSerializer.Serialize(listOutput, WorkloadListJsonSerializerContext.Default.ListOutput));

Commands\Workload\Search\WorkloadSearchVersionsCommand.cs (3)

101Reporter.WriteLine(JsonSerializer.Serialize(versions.Select(version => new Dictionary<string, string>() 125Reporter.WriteLine(JsonSerializer.Serialize(versions.Select(version => version.ToDictionary(_ => "workloadVersion", v => v)), WorkloadSearchVersionsJsonSerializerContext.Default.IEnumerableDictionaryStringString)); 138Reporter.WriteLine(JsonSerializer.Serialize(new Dictionary<string, Dictionary<string, string>>()

Commands\Workload\Update\WorkloadUpdateCommand.cs (1)

99Reporter.WriteLine(JsonSerializer.Serialize(packageUrls, WorkloadInstallJsonSerializerContext.Default.IEnumerableString));

NugetSearch\NugetSearchApiResultDeserializer.cs (1)

25var deserialized = JsonSerializer.Deserialize(json, NugetSearchApiJsonSerializerContext.Default.NugetSearchApiContainerSerializable);

SdkVulnerability\SdkReleaseMetadataCache.cs (2)

92return JsonSerializer.Deserialize(json, SdkVulnerabilityJsonContext.Default.SdkVulnerabilityInfo); 153var json = JsonSerializer.Serialize(info, SdkVulnerabilityJsonContext.Default.SdkVulnerabilityInfo);

SlnfFileHelper.cs (2)

87var json = JsonSerializer.Serialize(root, SlnfJsonSerializerContext.Default.SlnfRoot); 120var json = JsonSerializer.Serialize(root, SlnfJsonSerializerContext.Default.SlnfRoot);

src\sdk\src\Common\SdkVulnerabilityCacheReader.cs (1)

57return JsonSerializer.Deserialize(json, SdkVulnerabilityCacheJsonContext.Default.SdkVulnerabilityCacheSummary);

src\sdk\src\Common\WorkloadFileBasedInstall.cs (1)

61var historyRecord = JsonSerializer.Deserialize(File.ReadAllText(file), WorkloadHistoryJsonSerializerContext.Default.WorkloadHistoryRecord);

Telemetry\TelemetryDiskLogger.cs (1)

57activitiesArray.AddRange(activies.Select(r => JsonNode.Parse(JsonSerializer.Serialize(CreateActivityJsonModel(r), s_jsonContext.ActivityModel))));

ToolPackage\LocalToolsResolverCache.cs (3)

53JsonSerializer.Serialize(existingCacheTable.Concat(diffedRow), LocalToolsCacheJsonSerializerContext.Default.IEnumerableCacheRow)); 66JsonSerializer.Serialize(rowsToAdd, LocalToolsCacheJsonSerializerContext.Default.IEnumerableCacheRow)); 98JsonSerializer.Deserialize(_fileSystem.File.ReadAllText(packageCacheFile), LocalToolsCacheJsonSerializerContext.Default.CacheRowArray);

Program.cs (1)

370reporter.Output(JsonSerializer.Serialize(certReports, DevCertsJsonSerializerContext.Default.ListCertificateReport));

ReportWriter.cs (1)

27var formattedFilesJson = JsonSerializer.Serialize(formattedFiles, seralizerOptions);

Commands\CreateCommand.cs (1)

274reporter.Output(JsonSerializer.Serialize(jwt, JwtSerializerContext.Default.Jwt));

Commands\ListCommand.cs (2)

57reporter.Output(JsonSerializer.Serialize(jwts, JwtSerializerContext.Default.IDictionaryStringJwt)); 61reporter.Output(JsonSerializer.Serialize(Array.Empty<Jwt>(), JwtSerializerContext.Default.JwtArray));

Helpers\DevJwtCliHelpers.cs (1)

167reporter.Output(JsonSerializer.Serialize(jwt, JwtSerializerContext.Default.Jwt));

Helpers\JwtAuthenticationSchemeSettings.cs (4)

19var config = JsonSerializer.Deserialize(reader, JwtSerializerContext.Default.JsonObject); 61JsonSerializer.Serialize(writer, config, JwtSerializerContext.Default.JsonObject); 67var config = JsonSerializer.Deserialize(reader, JwtSerializerContext.Default.JsonObject); 77JsonSerializer.Serialize(writer, config, JwtSerializerContext.Default.JsonObject);

Helpers\JwtStore.cs (2)

33Jwts = JsonSerializer.Deserialize(fileStream, JwtSerializerContext.Default.IDictionaryStringJwt) ?? new Dictionary<string, Jwt>(); 50JsonSerializer.Serialize(fileStream, Jwts, JwtSerializerContext.Default.IDictionaryStringJwt);

Helpers\SigningKeysHandler.cs (4)

71secrets = JsonSerializer.Deserialize(secretsFileStream, JwtSerializerContext.Default.JsonObject); 88signingKeys.Add(JsonSerializer.SerializeToNode(key, JwtSerializerContext.Default.SigningKey)); 92secrets.Add(signkingKeysPropertyName, JsonSerializer.SerializeToNode(new[] { key }, JwtSerializerContext.Default.SigningKeyArray)); 96JsonSerializer.Serialize(secretsWriteStream, secrets, JwtSerializerContext.Default.JsonObject);

Internal\SecretsStore.cs (1)

98return JsonSerializer.Serialize(secrets, SecretManagerJsonSerializerContext.Default.IDictionaryStringString);

Watch\MsBuildFileSetFactory.cs (1)

90var result = await JsonSerializer.DeserializeAsync<MSBuildFileSetResult>(watchFile, cancellationToken: cancellationToken);

PowerShellScripts\BuildTestMatrixTests.cs (1)

587return JsonSerializer.Deserialize<CanonicalMatrix>(json)

PowerShellScripts\ExpandTestMatrixGitHubTests.cs (2)

673entries = JsonSerializer.Deserialize<ExpandedMatrixEntry[]>(include.GetRawText(), new JsonSerializerOptions 680var singleEntry = JsonSerializer.Deserialize<ExpandedMatrixEntry>(include.GetRawText(), new JsonSerializerOptions

PowerShellScripts\SplitTestMatrixByDepsTests.cs (3)

301return JsonSerializer.Serialize(matrix); 330entries = JsonSerializer.Deserialize<ExpandedMatrixEntry[]>(include.GetRawText(), new JsonSerializerOptions 337var singleEntry = JsonSerializer.Deserialize<ExpandedMatrixEntry>(include.GetRawText(), new JsonSerializerOptions

PowerShellScripts\SplitTestProjectsTests.cs (1)

204return JsonSerializer.Deserialize<TestPartitionsJson>(json, new JsonSerializerOptions

Shared\TestDataBuilder.cs (5)

53var json = JsonSerializer.Serialize(metadata, s_jsonOptions); 96var json = JsonSerializer.Serialize(metadata, s_jsonOptions); 121var json = JsonSerializer.Serialize(data, s_jsonOptions); 140var json = JsonSerializer.Serialize(data, s_jsonOptions); 162var json = JsonSerializer.Serialize(matrix, s_jsonOptions);

WorkflowScripts\AutoRerunTransientCiFailuresTests.cs (2)

1085string requestJson = JsonSerializer.Serialize(new HarnessRequest 1099HarnessResponse<T>? response = JsonSerializer.Deserialize<HarnessResponse<T>>(result.Output, s_jsonOptions);

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

_generated\19\BrowserConfigurationJsonContext.BrowserConfiguration.g.cs (1)

158global::System.Text.Json.JsonSerializer.Serialize(writer, __value_LogLevel, NullableInt32);

_generated\20\BrowserConfigurationJsonContext.ServerBrowserOptions.g.cs (2)

132global::System.Text.Json.JsonSerializer.Serialize(writer, __value_ReconnectionMaxRetries, NullableInt32); 138global::System.Text.Json.JsonSerializer.Serialize(writer, __value_ReconnectionRetryIntervalMilliseconds, NullableInt32);

_generated\21\BrowserConfigurationJsonContext.SsrBrowserOptions.g.cs (2)

112global::System.Text.Json.JsonSerializer.Serialize(writer, __value_DisableDomPreservation, NullableBoolean); 118global::System.Text.Json.JsonSerializer.Serialize(writer, __value_CircuitInactivityTimeoutMs, NullableInt32);

_generated\32\JsonTempDataSerializerContext.ICollectionNullableBoolean.g.cs (1)

59global::System.Text.Json.JsonSerializer.Serialize(writer, element, NullableBoolean);

_generated\34\JsonTempDataSerializerContext.ICollectionNullableDateTime.g.cs (1)

59global::System.Text.Json.JsonSerializer.Serialize(writer, element, NullableDateTime);

_generated\36\JsonTempDataSerializerContext.ICollectionNullableGuid.g.cs (1)

59global::System.Text.Json.JsonSerializer.Serialize(writer, element, NullableGuid);

_generated\38\JsonTempDataSerializerContext.ICollectionNullableInt32.g.cs (1)

59global::System.Text.Json.JsonSerializer.Serialize(writer, element, NullableInt32);

_generated\42\JsonTempDataSerializerContext.IDictionaryStringNullableBoolean.g.cs (1)

60global::System.Text.Json.JsonSerializer.Serialize(writer, entry.Value, NullableBoolean);

_generated\44\JsonTempDataSerializerContext.IDictionaryStringNullableDateTime.g.cs (1)

60global::System.Text.Json.JsonSerializer.Serialize(writer, entry.Value, NullableDateTime);

_generated\46\JsonTempDataSerializerContext.IDictionaryStringNullableGuid.g.cs (1)

60global::System.Text.Json.JsonSerializer.Serialize(writer, entry.Value, NullableGuid);

_generated\48\JsonTempDataSerializerContext.IDictionaryStringNullableInt32.g.cs (1)

60global::System.Text.Json.JsonSerializer.Serialize(writer, entry.Value, NullableInt32);

Assets\ImportMapDefinition.cs (1)

208_json ??= JsonSerializer.Serialize(this, ImportMapSerializerContext.CustomEncoder.Options);

Builder\ResourceCollectionUrlEndpoint.cs (1)

102JsonSerializer.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));

Rendering\EndpointHtmlRenderer.Streaming.cs (3)

294var serializedStartRecord = JsonSerializer.Serialize(marker, ServerComponentSerializationSettings.JsonSerializationOptions); 318var serializedEndRecord = JsonSerializer.Serialize(endMarker, ServerComponentSerializationSettings.JsonSerializationOptions); 363var configJson = JsonSerializer.Serialize(config, BrowserConfigurationJsonContext.Default.BrowserConfiguration);

SessionCascadingValueSupplier.cs (2)

96var json = JsonSerializer.Serialize(value, value.GetType(), _jsonOptions); 167return JsonSerializer.Deserialize(json, _propertyType, _jsonOptions);

src\aspnetcore\src\Components\Shared\src\RenderFragmentSerializer.cs (1)

315JsonElement je => JsonSerializer.Deserialize<SerializedRenderFragment>(je.GetRawText(), jsonOptions),

src\aspnetcore\src\Shared\Components\PrerenderComponentApplicationStore.cs (2)

33var state = JsonSerializer.Deserialize( 53JsonSerializer.SerializeToUtf8Bytes(state);

src\aspnetcore\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);

_generated\1\CircuitPersistenceManagerSerializerContext.ComponentMarker.g.cs (2)

247global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Microsoft.AspNetCore.Components.ComponentMarker)value).Key, NullableComponentMarkerKey); 249global::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 (2)

58var serialized = JsonSerializer.Deserialize<SerializedRenderFragment>( 82var 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\aspnetcore\src\Components\Shared\src\RenderFragmentSerializer.cs (1)

315JsonElement je => JsonSerializer.Deserialize<SerializedRenderFragment>(je.GetRawText(), jsonOptions),

src\aspnetcore\src\Shared\Components\PrerenderComponentApplicationStore.cs (2)

33var state = JsonSerializer.Deserialize( 53JsonSerializer.SerializeToUtf8Bytes(state);

src\aspnetcore\src\Shared\Components\ServerComponentSerializer.cs (1)

51var serializedServerComponentBytes = JsonSerializer.SerializeToUtf8Bytes(serverComponent, ServerComponentSerializationSettings.JsonSerializationOptions);

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)

132var argsJson = JsonSerializer.Serialize(args, newJsonOptions);

_generated\1\ExtensionsExceptionJsonContext.ExceptionExtensionData.g.cs (1)

177global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Microsoft.AspNetCore.Diagnostics.ExceptionExtensionData)value).RouteValues, RouteValueDictionary);

DeveloperExceptionPage\DeveloperExceptionPageMiddlewareImpl.cs (1)

260problemDetails.Extensions["exception"] = JsonSerializer.SerializeToElement(new ExceptionExtensionData

_generated\1\SourceGenerationContext.StaticWebAssetManifest.g.cs (1)

117global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Microsoft.AspNetCore.StaticWebAssets.ManifestStaticWebAssetFileProvider.StaticWebAssetManifest)value).Root, StaticWebAssetNode);

_generated\6\SourceGenerationContext.DictionaryStringStaticWebAssetNode.g.cs (1)

62global::System.Text.Json.JsonSerializer.Serialize(writer, entry.Value, StaticWebAssetNode);

_generated\7\SourceGenerationContext.IDictionaryStringStaticWebAssetNode.g.cs (1)

62global::System.Text.Json.JsonSerializer.Serialize(writer, entry.Value, StaticWebAssetNode);

src\aspnetcore\src\Shared\StaticWebAssets\ManifestStaticWebAssetFileProvider.cs (2)

319return JsonSerializer.Deserialize( 379var parsed = JsonSerializer.Deserialize(ref reader, SourceGenerationContext.DefaultWithConverter.IDictionaryStringStaticWebAssetNode)!;

HttpRequestJsonExtensions.cs (15)

HttpResponseJsonExtensions.cs (10)

JsonOptions.cs (1)

27TypeInfoResolver = JsonSerializer.IsReflectionEnabledByDefault ? CreateDefaultTypeResolver() : JsonTypeInfoResolver.Combine()

ServerSentEventsResult.cs (1)

90var json = JsonSerializer.SerializeToUtf8Bytes(item.Data, typeInfo);

_generated\12\IdentityEndpointsJsonSerializerContext.TwoFactorRequest.g.cs (1)

169global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Microsoft.AspNetCore.Identity.Data.TwoFactorRequest)value).Enable, NullableBoolean);

_generated\22\IdentityJsonSerializerContext.AuthenticatorAssertionResponse.g.cs (4)

161global::System.Text.Json.JsonSerializer.Serialize(writer, __value_AuthenticatorData, BufferSource); 167global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Signature, BufferSource); 173global::System.Text.Json.JsonSerializer.Serialize(writer, __value_UserHandle, BufferSource); 179global::System.Text.Json.JsonSerializer.Serialize(writer, __value_ClientDataJSON, BufferSource);

_generated\23\IdentityJsonSerializerContext.AuthenticatorAttestationResponse.g.cs (2)

138global::System.Text.Json.JsonSerializer.Serialize(writer, __value_AttestationObject, BufferSource); 150global::System.Text.Json.JsonSerializer.Serialize(writer, __value_ClientDataJSON, BufferSource);

_generated\26\IdentityJsonSerializerContext.CollectedClientData.g.cs (2)

206global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Challenge, BufferSource); 217global::System.Text.Json.JsonSerializer.Serialize(writer, __value_CrossOrigin, NullableBoolean);

_generated\28\IdentityJsonSerializerContext.PasskeyAssertionState.g.cs (1)

110global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Microsoft.AspNetCore.Identity.PasskeyAssertionState)value).Challenge, ReadOnlyMemoryByte);

_generated\29\IdentityJsonSerializerContext.PasskeyAttestationState.g.cs (1)

113global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Microsoft.AspNetCore.Identity.PasskeyAttestationState)value).Challenge, ReadOnlyMemoryByte);

_generated\31\IdentityJsonSerializerContext.PublicKeyCredentialAuthenticatorAssertionResponse.g.cs (2)

182global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Id, BufferSource); 190global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Microsoft.AspNetCore.Identity.PublicKeyCredential<global::Microsoft.AspNetCore.Identity.AuthenticatorAssertionResponse>)value).ClientExtensionResults, JsonElement);

_generated\32\IdentityJsonSerializerContext.PublicKeyCredentialAuthenticatorAttestationResponse.g.cs (2)

182global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Id, BufferSource); 190global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Microsoft.AspNetCore.Identity.PublicKeyCredential<global::Microsoft.AspNetCore.Identity.AuthenticatorAttestationResponse>)value).ClientExtensionResults, JsonElement);

_generated\33\IdentityJsonSerializerContext.PublicKeyCredentialCreationOptions.g.cs (3)

321global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Challenge, BufferSource); 333global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Timeout, NullableUInt64); 368global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Extensions, NullableJsonElement);

_generated\34\IdentityJsonSerializerContext.PublicKeyCredentialDescriptor.g.cs (1)

145global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Id, BufferSource);

_generated\35\IdentityJsonSerializerContext.PublicKeyCredentialParameters.g.cs (1)

112global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Microsoft.AspNetCore.Identity.PublicKeyCredentialParameters)value).Alg, COSEAlgorithmIdentifier);

_generated\36\IdentityJsonSerializerContext.PublicKeyCredentialRequestOptions.g.cs (3)

219global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Challenge, BufferSource); 225global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Timeout, NullableUInt64); 253global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Extensions, NullableJsonElement);

_generated\38\IdentityJsonSerializerContext.PublicKeyCredentialUserEntity.g.cs (1)

141global::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) 382credential = JsonSerializer.Deserialize(context.CredentialJson, IdentityJsonSerializerContext.Default.PublicKeyCredentialAuthenticatorAssertionResponse) 397assertionState = JsonSerializer.Deserialize(assertionStateJson, IdentityJsonSerializerContext.Default.PasskeyAssertionState) 578clientData = JsonSerializer.Deserialize(utf8Json.Span, IdentityJsonSerializerContext.Default.CollectedClientData)

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()

Rendering\SystemTextJsonHelper.cs (1)

25var json = JsonSerializer.Serialize(value, _htmlSafeJsonSerializerOptions);

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

StaticAssetsManifest.cs (1)

32var result = JsonSerializer.Deserialize(content, StaticAssetsManifestJsonContext.Default.StaticAssetsManifest) ??

src\sdk\src\Dotnet.Watch\Web.Middleware\BlazorWasmHotReloadMiddleware.cs (2)

82await JsonSerializer.SerializeAsync(context.Response.Body, Updates, s_jsonSerializerOptions); 87var update = await JsonSerializer.DeserializeAsync<Update>(context.Request.Body, s_jsonSerializerOptions);

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

Rpc\RpcClient.cs (3)

63response = JsonSerializer.Deserialize<Response>(line, JsonSettings.SingleLineSerializerOptions); 158Parameters = [.. parameters.Select(static p => JsonSerializer.SerializeToElement(p, JsonSettings.SingleLineSerializerOptions))] 161var requestJson = JsonSerializer.Serialize(request, JsonSettings.SingleLineSerializerOptions) + Environment.NewLine;

Rpc\RpcServer.cs (3)

79request = JsonSerializer.Deserialize<Request>(line, JsonSettings.SingleLineSerializerOptions); 152response = new Response { Id = request.Id, Value = result is not null ? JsonSerializer.SerializeToElement(result, JsonSettings.SingleLineSerializerOptions) : null }; 162var responseJson = JsonSerializer.Serialize(response, JsonSettings.SingleLineSerializerOptions);

_generated\4\ContractDescriptorContext.DictionaryStringFieldDescriptor.g.cs (1)

60global::System.Text.Json.JsonSerializer.Serialize(writer, entry.Value, FieldDescriptor);

_generated\5\ContractDescriptorContext.DictionaryStringGlobalDescriptor.g.cs (1)

60global::System.Text.Json.JsonSerializer.Serialize(writer, entry.Value, GlobalDescriptor);

_generated\6\ContractDescriptorContext.DictionaryStringTypeDescriptor.g.cs (1)

60global::System.Text.Json.JsonSerializer.Serialize(writer, entry.Value, TypeDescriptor);

_generated\7\ContractDescriptorContext.DictionaryStringJsonElement.g.cs (1)

60global::System.Text.Json.JsonSerializer.Serialize(writer, entry.Value, JsonElement);

ContractDescriptorParser.cs (2)

32return JsonSerializer.Deserialize(json, ContractDescriptorContext.Default.ContractDescriptor); 140var field = JsonSerializer.Deserialize(ref reader, ContractDescriptorContext.Default.FieldDescriptor);

Commands\Test\TestCommandDefinition.cs (1)

43var globalJson = JsonSerializer.Deserialize(jsonText, GlobalJsonSerializerContext.Default.GlobalJsonModel);

src\GetCMakeArtifactsFromFileApi.cs (3)

74var index = JsonSerializer.Deserialize<CMakeFileApiIndex>(indexJson, options); 92var codeModel = JsonSerializer.Deserialize<CMakeCodeModel>(codeModelJson, options); 175var targetDetails = JsonSerializer.Deserialize<CMakeTargetDetails>(targetJson, options);

DeltaProject.cs (1)

121System.Text.Json.JsonSerializer.Serialize(output.UpdateHandlerInfoStream, new UpdateHandlerInfo (update.UpdatedTypes));

Runners\ScriptRunner.cs (1)

44await System.Text.Json.JsonSerializer.SerializeAsync(s, summary, cancellationToken: ct);

Script\Json\Parsing.cs (1)

31var result = await JsonSerializer.DeserializeAsync<Script>(stream, options: options, cancellationToken: ct);

Script\Json\ScriptCapabilitiesConverter.cs (1)

26var elems = JsonSerializer.Deserialize<string[]>(ref reader, options);

HotReloadDeltaGeneratorComputeScriptOutputs.cs (1)

138var json = await JsonSerializer.DeserializeAsync<Script.Json.Script>(stream, options: options, cancellationToken: ct);

Process\LaunchSettingsProfile.cs (1)

48launchSettings = JsonSerializer.Deserialize<LaunchSettingsJson>(

src\sdk\src\Dotnet.Watch\AspireService\AspireServerService.cs (1)

187var jsonSerialized = JsonSerializer.SerializeToUtf8Bytes(notification, JsonSerializerOptions);

src\sdk\src\Dotnet.Watch\HotReloadClient\Web\AbstractBrowserRefreshServer.cs (6)

219=> JsonSerializer.SerializeToUtf8Bytes(value, s_jsonSerializerOptions); 222=> JsonSerializer.Deserialize<TValue>(value, s_jsonSerializerOptions) ?? throw new InvalidDataException("Unexpected null object"); 306var message = JsonSerializer.SerializeToUtf8Bytes(new JasonUpdateStaticFileRequest { Path = relativeUrl }, s_jsonSerializerOptions); 314public static readonly ReadOnlyMemory<byte> Message = JsonSerializer.SerializeToUtf8Bytes(new JsonWaitRequest(), s_jsonSerializerOptions); 320public static readonly ReadOnlyMemory<byte> Message = JsonSerializer.SerializeToUtf8Bytes(new JsonReloadRequest(), s_jsonSerializerOptions); 326public static readonly ReadOnlyMemory<byte> Message = JsonSerializer.SerializeToUtf8Bytes(new JsonRefreshBrowserRequest(), s_jsonSerializerOptions);

src\sdk\src\Dotnet.Watch\HotReloadClient\Web\StaticWebAssetsManifest.cs (1)

121manifest = JsonSerializer.Deserialize<ManifestJson>(stream, s_options);

WebAssemblyHotReload.cs (3)

100var updates = deltasJson != "" ? JsonSerializer.Deserialize<Update[]>(deltasJson, s_jsonSerializerOptions) : null; 162var deltas = JsonSerializer.Deserialize(deltasJson, jsonContext.DeltaArray); 169return result == null ? null : JsonSerializer.Serialize(result, jsonContext.LogEntryArray);

LaunchSettings\ExecutableLaunchProfileParser.cs (1)

21var profile = JsonSerializer.Deserialize(json, LaunchProfileJsonSerializerContext.Default.ExecutableLaunchProfile);

LaunchSettings\ProjectLaunchProfileParser.cs (1)

20var profile = JsonSerializer.Deserialize(json, LaunchProfileJsonSerializerContext.Default.ProjectLaunchProfile);

_generated\8\InstallStateJsonSerializerContext.InstallStateContents.g.cs (1)

132global::System.Text.Json.JsonSerializer.Serialize(writer, __value_UseWorkloadSets, NullableBoolean);

src\sdk\src\Cli\dotnet\Commands\Workload\InstallStateContents.cs (2)

26return JsonSerializer.Deserialize(contents, InstallStateJsonSerializerContext.Default.InstallStateContents) ?? new InstallStateContents(); 36return JsonSerializer.Serialize(this, InstallStateJsonSerializerContext.Default.InstallStateContents);

src\sdk\src\Resolvers\Microsoft.NET.Sdk.WorkloadManifestReader\WorkloadSet.cs (2)

68return FromDictionaryForJson(JsonSerializer.Deserialize(json, WorkloadSetJsonSerializerContext.Default.IDictionaryStringString)!, defaultFeatureBand); 118var json = JsonSerializer.Serialize(ToDictionaryForJson(), WorkloadSetJsonSerializerContext.Default.DictionaryStringString);

Model\JsonDocument.cs (2)

26_json = JsonSerializer.Deserialize<Dictionary<string, string>>(text); 31writer.Write(JsonSerializer.Serialize(_json, typeof(Dictionary<string, string>), s_serializerOptions));

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)

473element = JsonSerializer.SerializeToElement(content, unknownContentTypeInfo); 493return JsonSerializer.Serialize(output, _defaultOptions.GetTypeInfo(typeof(IList<object>))); 639JsonSerializer.Serialize(options.Tools.Select(t => t switch 799JsonSerializer.Serialize(new object[1] { new OtelGenericPart { Content = options!.Instructions } }, _defaultOptions.GetTypeInfo(typeof(IList<object>)))); 946private 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);

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)

114JsonNode? jsonNode = JsonSerializer.SerializeToNode(value, jti); 116JsonSerializer.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 (5)

172return JsonSerializer.SerializeToElement(schema, JsonContextNoIndentation.Default.JsonNode); 201return JsonSerializer.SerializeToElement(schema, JsonContextNoIndentation.Default.JsonNode); 243? JsonSerializer.SerializeToNode(defaultValue, serializerOptions.GetTypeInfo(defaultValue.GetType())) 369JsonNode? defaultValueNode = JsonSerializer.SerializeToNode(defaultValue, ctx.TypeInfo); 692if (allowedValue is not null && JsonSerializer.SerializeToNode(allowedValue, serializerOptions.GetTypeInfo(allowedValue.GetType())) is { } valueNode)

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!);

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)

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)

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)

HostedMcpServerToolApprovalModeTests.cs (6)

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 _)); 606JsonNode? schemaAsNode = JsonSerializer.SerializeToNode(schema, options); 619JsonNode? serializedValue = JsonSerializer.SerializeToNode(testData.Value, testData.Type, options); 659AssertDeepEquals(JsonSerializer.Deserialize( 895AssertDeepEquals(JsonSerializer.Deserialize( 1171string json = JsonSerializer.Serialize(c, options); 1174AIContent? deserialized = JsonSerializer.Deserialize<AIContent>(json, options); 1212Assert.Throws<InvalidOperationException>(() => JsonSerializer.Serialize(c, options));

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)!;

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(

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(

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)

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

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

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

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)

187result = JsonSerializer.Serialize(resultContent.Result, AIJsonUtilities.DefaultOptions.GetTypeInfo(typeof(object))); 214ChatToolCall.CreateFunctionToolCall(fc.CallId, fc.Name, new(JsonSerializer.SerializeToUtf8Bytes( 670BinaryData.FromBytes(JsonSerializer.SerializeToUtf8Bytes(jsonSchema, OpenAIJsonContext.Default.JsonElement)),

OpenAIClientExtensions.cs (4)

200var tool = JsonSerializer.Deserialize(jsonSchema, OpenAIJsonContext.Default.ToolJson)!; 201var functionParameters = BinaryData.FromBytes(JsonSerializer.SerializeToUtf8Bytes(tool, OpenAIJsonContext.Default.ToolJson)); 217static json => JsonSerializer.Deserialize(json, OpenAIJsonContext.Default.IDictionaryStringObject)!); 230static utf8json => JsonSerializer.Deserialize(utf8json, OpenAIJsonContext.Default.IDictionaryStringObject)!);

OpenAIImageGenerator.cs (1)

124var outputFormatString = JsonSerializer.Deserialize(outputFormat, stringJsonTypeInfo);

OpenAIResponsesChatClient.cs (10)

217Arguments = JsonSerializer.Deserialize(mtcari.ToolArguments.ToMemory().Span, OpenAIJsonContext.Default.IReadOnlyDictionaryStringObject)!, 456Arguments = JsonSerializer.Deserialize(mtcari.ToolArguments.ToMemory().Span, OpenAIJsonContext.Default.IReadOnlyDictionaryStringObject)!, 849BinaryData.FromBytes(JsonSerializer.SerializeToUtf8Bytes(jsonSchema, OpenAIJsonContext.Default.JsonElement)), 1080Text = JsonSerializer.Serialize(content, AIJsonUtilities.DefaultOptions.GetTypeInfo(typeof(object))), 1094outputItem.Patch.Set("$.output"u8, JsonSerializer.SerializeToUtf8Bytes(elements, OpenAIJsonContext.Default.ListFunctionToolCallOutputElement).AsSpan()); 1116result = JsonSerializer.Serialize(resultContent.Result, AIJsonUtilities.DefaultOptions.GetTypeInfo(typeof(object))); 1163BinaryData.FromBytes(JsonSerializer.SerializeToUtf8Bytes( 1173BinaryData.FromBytes(JsonSerializer.SerializeToUtf8Bytes(mcpApprovalRequestContent.ToolCall.Arguments!, OpenAIJsonContext.Default.IReadOnlyDictionaryStringObject))); 1188BinaryData.FromBytes(JsonSerializer.SerializeToUtf8Bytes(associatedCall.Arguments!, OpenAIJsonContext.Default.IReadOnlyDictionaryStringObject))); 1380Arguments = JsonSerializer.Deserialize(mtci.ToolArguments.ToMemory().Span, OpenAIJsonContext.Default.IReadOnlyDictionaryStringObject)!,

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

ChatCompletion\ChatClientStructuredOutputExtensionsTests.cs (9)

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)

180JsonElement 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);

Internal\DefaultJsonSerializerFactory.cs (2)

151return JsonSerializer.Deserialize<T>(ref reader, Options)!; 159JsonSerializer.Serialize<T>(writer, value, Options);

SampleUsage.cs (2)

176return JsonSerializer.Deserialize<T>(bytes)!; 182JsonSerializer.Serialize(ms, info);

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

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

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

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

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

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

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)

SweepablePipelineTests.cs (1)

70Approvals.Verify(JsonSerializer.Serialize(pipeline, _jsonSerializerOptions));

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

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

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

Phi3Tests.cs (1)

109var json = JsonSerializer.Serialize(sizeInMB, new JsonSerializerOptions { WriteIndented = true });

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_1390cd9b-58e7-450e-8281-cfb73a6ee178.generated.cs (1)

25var schema = JsonSerializer.Deserialize<GetWeatherSchema>(

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

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

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

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)

229int[]? expected = JsonSerializer.Deserialize<int[]>(stream) as int[]; 304int[]? expected = JsonSerializer.Deserialize<int[]>(stream) as int[]; 341int[]? expected = JsonSerializer.Deserialize<int[]>(stream) as int[]; 360int[]? expected = JsonSerializer.Deserialize<int[]>(stream) as int[]; 379int[]? expected = JsonSerializer.Deserialize<int[]>(stream) as int[]; 398int[]? expected = JsonSerializer.Deserialize<int[]>(stream) as int[];

AuthHandshakeMessageHandler.cs (2)

495TokenResponse? tokenResponse = JsonSerializer.Deserialize<TokenResponse>(postResponse.Content.ReadAsStream(cancellationToken)); 539TokenResponse? token = JsonSerializer.Deserialize<TokenResponse>(tokenResponse.Content.ReadAsStream(cancellationToken));

ImageBuilder.cs (1)

94Manifest = JsonSerializer.SerializeToNode(newManifest)?.ToJsonString() ?? "",

ImageIndexGenerator.cs (1)

136return JsonSerializer.SerializeToNode(imageIndex, nullIgnoreOptions)?.ToJsonString(escapeOptions) ?? "";

ManifestV2.cs (1)

59public string GetDigest() => KnownDigest ??= DigestUtils.ComputeSha256Digest(JsonSerializer.SerializeToNode(this)?.ToJsonString() ?? string.Empty);

src\sdk\src\Common\VSHostObject.cs (1)

83List<TaskItemDto>? dtos = JsonSerializer.Deserialize<List<TaskItemDto>>(rawTaskItems);

Tasks\CreateImageIndex.cs (1)

120var manifestV2 = JsonSerializer.Deserialize<ManifestV2>(manifest);

VSHostObject.cs (1)

75List<TaskItemDto>? dtos = JsonSerializer.Deserialize<List<TaskItemDto>>(rawTaskItems);

_generated\18\InstallStateJsonSerializerContext.InstallStateContents.g.cs (1)

132global::System.Text.Json.JsonSerializer.Serialize(writer, __value_UseWorkloadSets, NullableBoolean);

_generated\2\SdkVulnerabilitySummaryContext.SdkVulnerabilitySummary.g.cs (1)

170global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Microsoft.NET.Build.Tasks.CheckSdkVulnerabilities.SdkVulnerabilitySummary)value).EolDate, NullableDateTime);

CheckSdkVulnerabilities.cs (1)

55summary = JsonSerializer.Deserialize(json, SdkVulnerabilitySummaryContext.Default.SdkVulnerabilitySummary);

src\sdk\src\Cli\dotnet\Commands\Workload\InstallStateContents.cs (2)

26return JsonSerializer.Deserialize(contents, InstallStateJsonSerializerContext.Default.InstallStateContents) ?? new InstallStateContents(); 36return JsonSerializer.Serialize(this, InstallStateJsonSerializerContext.Default.InstallStateContents);

src\sdk\src\Resolvers\Microsoft.NET.Sdk.WorkloadManifestReader\WorkloadSet.cs (2)

68return FromDictionaryForJson(JsonSerializer.Deserialize(json, WorkloadSetJsonSerializerContext.Default.IDictionaryStringString)!, defaultFeatureBand); 118var json = JsonSerializer.Serialize(ToDictionaryForJson(), WorkloadSetJsonSerializerContext.Default.DictionaryStringString);

ComHost\ClsidMap.cs (1)

70writer.Write(JsonSerializer.Serialize(clsidMap, s_jsonOptions));

AppSettingsTransform.cs (2)

64return JsonSerializer.Serialize(obj, 73return JsonSerializer.Deserialize<T>(jsonString,

src\sdk\src\Common\VSHostObject.cs (1)

83List<TaskItemDto>? dtos = JsonSerializer.Deserialize<List<TaskItemDto>>(rawTaskItems);

Tasks\Http\HttpClientExtensions.cs (1)

276return JsonSerializer.Deserialize<T>(reader.ReadToEnd(), s_defaultSerializerOptions);

Tasks\ZipDeploy\ZipDeploymentStatus.cs (1)

120return JsonSerializer.Deserialize<T>(jsonString,

Data\StaticAssetsManifest.cs (12)

Data\StaticWebAssetEndpointProperty.cs (2)

22internal static StaticWebAssetEndpointProperty[] FromMetadataValue(string value) => string.IsNullOrEmpty(value) ? [] : JsonSerializer.Deserialize(value, _jsonTypeInfo); 25JsonSerializer.Serialize(

Data\StaticWebAssetEndpointResponseHeader.cs (2)

22internal static StaticWebAssetEndpointResponseHeader[] FromMetadataValue(string value) => string.IsNullOrEmpty(value) ? [] : JsonSerializer.Deserialize(value, _jsonTypeInfo); 25JsonSerializer.Serialize(

Data\StaticWebAssetEndpointSelector.cs (2)

24public static StaticWebAssetEndpointSelector[] FromMetadataValue(string value) => string.IsNullOrEmpty(value) ? [] : JsonSerializer.Deserialize(value, _jsonTypeInfo); 27JsonSerializer.Serialize(

DefineStaticWebAssets.Cache.cs (2)

100var cache = JsonSerializer.Deserialize(existingManifestFile, DefineStaticWebAssetsSerializerContext.Default.DefineStaticWebAssetsCache); 120JsonSerializer.Serialize(manifestFile, this, DefineStaticWebAssetsSerializerContext.Default.DefineStaticWebAssetsCache);

GenerateStaticWebAssetsDevelopmentManifest.cs (1)

130var data = JsonSerializer.SerializeToUtf8Bytes(manifest, StaticWebAssetsJsonSerializerContext.RelaxedEscaping.StaticWebAssetsDevelopmentManifest);

GenerateStaticWebAssetsManifest.cs (1)

135var data = JsonSerializer.SerializeToUtf8Bytes(manifest, StaticWebAssetsJsonSerializerContext.RelaxedEscaping.StaticWebAssetsManifest);

JSModules\GenerateJSModuleManifest.cs (1)

38var data = JsonSerializer.SerializeToUtf8Bytes(modules, ManifestSerializationOptions);

OverrideHtmlAssetPlaceholders.cs (1)

72return $"<script type=\"importmap\">{JsonSerializer.Serialize(importMap, ImportMapSerializerContext.CustomEncoder.Options)}</script>";

ReadPackageAssetsManifest.cs (1)

160manifest = JsonSerializer.Deserialize(json,

ServiceWorker\GenerateServiceWorkerAssetsManifest.cs (1)

99var data = JsonSerializer.Serialize(manifest, ManifestSerializationOptions);

StaticWebAssetsGeneratePackManifest.cs (1)

79var data = JsonSerializer.SerializeToUtf8Bytes(manifest, ManifestSerializationOptions);

StaticWebAssetsReadPackManifest.cs (1)

31var manifest = JsonSerializer.Deserialize<StaticWebAssetsPackManifest>(File.ReadAllBytes(ManifestPath));

Utils\ArtifactWriter.cs (1)

15var data = JsonSerializer.SerializeToUtf8Bytes(manifest, serializer);

_generated\8\InstallStateJsonSerializerContext.InstallStateContents.g.cs (1)

132global::System.Text.Json.JsonSerializer.Serialize(writer, __value_UseWorkloadSets, NullableBoolean);

src\sdk\src\Cli\dotnet\Commands\Workload\InstallStateContents.cs (2)

26return JsonSerializer.Deserialize(contents, InstallStateJsonSerializerContext.Default.InstallStateContents) ?? new InstallStateContents(); 36return JsonSerializer.Serialize(this, InstallStateJsonSerializerContext.Default.InstallStateContents);

WorkloadSet.cs (2)

68return FromDictionaryForJson(JsonSerializer.Deserialize(json, WorkloadSetJsonSerializerContext.Default.IDictionaryStringString)!, defaultFeatureBand); 118var json = JsonSerializer.Serialize(ToDictionaryForJson(), WorkloadSetJsonSerializerContext.Default.DictionaryStringString);

_generated\23\TemplateCacheJsonSerializerContext.ITemplateParameter.g.cs (1)

348global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Microsoft.TemplateEngine.Abstractions.ITemplateParameter)value).Priority, TemplateParameterPriority);

_generated\27\TemplateCacheJsonSerializerContext.TemplateParameterPrecedence.g.cs (1)

169global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Microsoft.TemplateEngine.Abstractions.TemplateParameterPrecedence)value).PrecedenceDefinition, PrecedenceDefinition);

src\sdk\src\TemplateEngine\Shared\JExtensions.cs (3)

460JsonSerializer.Serialize(fileStream, obj, jsonTypeInfo); 488return JsonSerializer.Serialize(obj, SerializerOptions); 598string json = JsonSerializer.Serialize(obj, SerializerOptions);

src\sdk\src\TemplateEngine\Shared\JExtensions.cs (3)

460JsonSerializer.Serialize(fileStream, obj, jsonTypeInfo); 488return JsonSerializer.Serialize(obj, SerializerOptions); 598string json = JsonSerializer.Serialize(obj, SerializerOptions);

src\sdk\src\TemplateEngine\Shared\JExtensions.cs (3)

460JsonSerializer.Serialize(fileStream, obj, jsonTypeInfo); 488return JsonSerializer.Serialize(obj, SerializerOptions); 598string json = JsonSerializer.Serialize(obj, SerializerOptions);

TemplateSearchCache\TemplatePackageSearchData.Json.cs (2)

131JsonSerializer.Serialize(writer, value.Templates, options); 138JsonSerializer.Serialize(writer, item.Value, options);

TemplateSearchCache\TemplateSearchData.Json.cs (2)

180JsonSerializer.Serialize(writer, value.TemplateInfo.BaselineInfo, options); 199JsonSerializer.Serialize(writer, item.Value, options);

JsonDataSerializer.Stj.cs (5)

108result = JsonSerializer.Deserialize<T>(payloadElement, payloadOptions); 191var serializedPayload = JsonSerializer.SerializeToElement(payload, payloadOptions); 211return JsonSerializer.Deserialize<T>(value, FastOptions); 223return JsonSerializer.Serialize(data, options); 235return JsonSerializer.Deserialize<T>(data, options);

Serialization\AfterTestRunEndResultConverter.cs (2)

55return JsonSerializer.Deserialize<T>(prop.GetRawText(), options); 64JsonSerializer.Serialize(writer, value, options);

Serialization\AttachmentConverters.cs (2)

35attachmentSet.Attachments.Add(JsonSerializer.Deserialize<UriDataAttachment>(attachment.GetRawText(), options)!); 49JsonSerializer.Serialize(writer, value.Attachments, options);

Serialization\DiscoveryCriteriaConverter.cs (2)

78return JsonSerializer.Deserialize<T>(prop.GetRawText(), options); 87JsonSerializer.Serialize(writer, value, options);

Serialization\ObjectConverter.cs (2)

66JsonSerializer.Serialize(writer, value, value.GetType(), options); 123JsonSerializer.Serialize(writer, kvp.Value, kvp.Value?.GetType() ?? typeof(object), options);

Serialization\TestCaseConverter.cs (3)

42var testProperty = JsonSerializer.Deserialize<TestProperty>(keyElement.GetRawText(), options); 156JsonSerializer.Serialize(writer, property, options); 166JsonSerializer.Serialize(writer, property, options);

Serialization\TestCaseConverterV2.cs (3)

52var testProperty = JsonSerializer.Deserialize<TestProperty>(keyElement, options); 94JsonSerializer.Serialize(writer, property.Key, options); 102JsonSerializer.Serialize(writer, property.Value, property.Value.GetType(), options);

Serialization\TestExecutionContextConverter.cs (2)

43context.FilterOptions = JsonSerializer.Deserialize<FilterOptions>(filterOptions.GetRawText(), options); 65JsonSerializer.Serialize(writer, value.FilterOptions, options);

Serialization\TestObjectBaseConverter.cs (3)

56var testProperty = JsonSerializer.Deserialize<TestProperty>(keyElement.GetRawText(), options); 92JsonSerializer.Serialize(writer, property.Key, options); 100JsonSerializer.Serialize(writer, property.Value, property.Value.GetType(), options);

Serialization\TestObjectConverter.cs (3)

44var testProperty = JsonSerializer.Deserialize<TestProperty>(keyElement, options); 78JsonSerializer.Serialize(writer, kvp.Key, options); 86JsonSerializer.Serialize(writer, kvp.Value, kvp.Value.GetType(), options);

Serialization\TestResultConverter.cs (9)

27var testCase = JsonSerializer.Deserialize<TestCase>(testCaseElement, options)!; 37testResult.Attachments.Add(JsonSerializer.Deserialize<AttachmentSet>(attachment, options)!); 49testResult.Messages.Add(JsonSerializer.Deserialize<TestResultMessage>(message, options)!); 63var testProperty = JsonSerializer.Deserialize<TestProperty>(property.GetProperty("Key"), options)!; 118JsonSerializer.Serialize(writer, value.TestCase, options); 120JsonSerializer.Serialize(writer, value.Attachments, options); 122JsonSerializer.Serialize(writer, value.Messages, options); 181JsonSerializer.Serialize(writer, property, options); 191JsonSerializer.Serialize(writer, property, options);

Serialization\TestResultConverterV2.cs (9)

30var testCase = JsonSerializer.Deserialize<TestCase>(testCaseElement, options)!; 40testResult.Attachments.Add(JsonSerializer.Deserialize<AttachmentSet>(attachment, options)!); 52testResult.Messages.Add(JsonSerializer.Deserialize<TestResultMessage>(message, options)!); 83var testProperty = JsonSerializer.Deserialize<TestProperty>(keyElement, options)!; 111JsonSerializer.Serialize(writer, value.TestCase, options); 115JsonSerializer.Serialize(writer, value.Attachments, options); 125JsonSerializer.Serialize(writer, value.Messages, options); 139JsonSerializer.Serialize(writer, property.Key, options); 147JsonSerializer.Serialize(writer, property.Value, property.Value.GetType(), options);

Serialization\TestRunChangedEventArgsConverter.cs (2)

54return JsonSerializer.Deserialize<T>(prop.GetRawText(), options); 63JsonSerializer.Serialize(writer, value, options);

Serialization\TestRunCompleteEventArgsConverter.cs (2)

69return JsonSerializer.Deserialize<T>(prop.GetRawText(), options); 78JsonSerializer.Serialize(writer, value, options);

_generated\10\PackageSearchJsonContext.NuGetLicenseExpression.g.cs (1)

89global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::NuGet.Packaging.Licenses.NuGetLicenseExpression)value).Type, LicenseExpressionType);

_generated\13\PackageSearchJsonContext.IPackageSearchMetadata.g.cs (8)

_generated\14\PackageSearchJsonContext.PackageVulnerabilityMetadata.g.cs (1)

109global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::NuGet.Protocol.PackageVulnerabilityMetadata)value).AdvisoryUrl, Uri);

_generated\15\PackageSearchJsonContext.FloatRange.g.cs (1)

173global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::NuGet.Versioning.FloatRange)value).FloatBehavior, NuGetVersionFloatBehavior);

_generated\16\PackageSearchJsonContext.NuGetVersion.g.cs (1)

332global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::NuGet.Versioning.NuGetVersion)value).Version, Version);

_generated\24\PackageSearchJsonContext.ListPackageSearchProblem.g.cs (1)

59global::System.Text.Json.JsonSerializer.Serialize(writer, value[i], PackageSearchProblem);

_generated\5\PackageSearchJsonContext.NuGetFramework.g.cs (2)

397global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::NuGet.Frameworks.NuGetFramework)value).Version, Version); 400global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::NuGet.Frameworks.NuGetFramework)value).PlatformVersion, Version);

_generated\8\PackageSearchJsonContext.LicenseMetadata.g.cs (3)

192global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::NuGet.Packaging.LicenseMetadata)value).Type, LicenseType); 199global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::NuGet.Packaging.LicenseMetadata)value).Version, Version); 201global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::NuGet.Packaging.LicenseMetadata)value).LicenseUrl, Uri);

Commands\PackageSearch\PackageSearchResultJsonRenderer.cs (1)

57var json = JsonSerializer.Serialize(_packageSearchMainOutput, new PackageSearchJsonContext(options).SearchMainOutput);

NupkgMetadata\NupkgMetadataFileFormat.cs (2)

47NupkgMetadataFile? nupkgMetadata = JsonSerializer.Deserialize<NupkgMetadataFile>(stream, JsonContext.NupkgMetadataFile); 89JsonSerializer.Serialize(stream, hashFile, JsonContext.NupkgMetadataFile);

_generated\5\CacheFileSourceGen.IAssetsLogMessage.g.cs (3)

311global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::NuGet.ProjectModel.IAssetsLogMessage)value).Level, LogLevel); 313global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::NuGet.ProjectModel.IAssetsLogMessage)value).Code, NuGetLogCode); 317global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::NuGet.ProjectModel.IAssetsLogMessage)value).WarningLevel, WarningLevel);

CacheFileFormat.cs (4)

45return JsonSerializer.Deserialize(ref reader, (JsonTypeInfo<AssetsLogMessage>)options.GetTypeInfo(typeof(AssetsLogMessage))); 50JsonSerializer.Serialize(writer, (AssetsLogMessage)value, (JsonTypeInfo<AssetsLogMessage>)options.GetTypeInfo(typeof(AssetsLogMessage))); 62return JsonSerializer.Deserialize(utf8Json: stream, (JsonTypeInfo<CacheFile>)SerializerOptions.GetTypeInfo(typeof(CacheFile))); 100textWriter.Write(JsonSerializer.Serialize(cacheFile, (JsonTypeInfo<CacheFile>)SerializerOptions.GetTypeInfo(typeof(CacheFile))));

_generated\10\JsonContext.NuGetVersion.g.cs (1)

332global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::NuGet.Versioning.NuGetVersion)value).Version, Version);

_generated\16\JsonContext.ListServiceIndexEntryModel.g.cs (1)

59global::System.Text.Json.JsonSerializer.Serialize(writer, value[i], ServiceIndexEntryModel);

_generated\4\JsonContext.PackageVulnerabilityInfo.g.cs (2)

131global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::NuGet.Protocol.Model.PackageVulnerabilityInfo)value).Url, Uri); 133global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::NuGet.Protocol.Model.PackageVulnerabilityInfo)value).Severity, PackageVulnerabilitySeverity);

_generated\7\JsonContext.V3VulnerabilityIndexEntry.g.cs (1)

153global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::NuGet.Protocol.Model.V3VulnerabilityIndexEntry)value).Url, Uri);

_generated\9\JsonContext.FloatRange.g.cs (1)

173global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::NuGet.Versioning.FloatRange)value).FloatBehavior, NuGetVersionFloatBehavior);

Providers\RepositorySignatureResourceProvider.cs (1)

94var model = await JsonSerializer.DeserializeAsync(

Providers\ServiceIndexResourceV3Provider.cs (1)

214index = await JsonSerializer.DeserializeAsync(stream, JsonContext.Default.ServiceIndexModel, token);

RemoteRepositories\HttpFileSystemBasedFindPackageByIdResource.cs (1)

583var json = await JsonSerializer.DeserializeAsync(stream, JsonContext.Default.FlatContainerVersionList, cancellationToken: token);

Resources\AutoCompleteResourceV3.cs (1)

79return await JsonSerializer.DeserializeAsync(stream, JsonContext.Default.AutoCompleteModel, token);

Resources\ServiceIndexResourceV3.cs (1)

70get { return _json ??= JsonSerializer.Serialize(_model, JsonContext.Default.ServiceIndexModel); }

Resources\VulnerabilityInfoResourceV3.cs (2)

50await JsonSerializer.DeserializeAsync(result.Stream!, JsonContext.Default.VulnerabilityIndex); 102await JsonSerializer.DeserializeAsync(result.Stream!, JsonContext.Default.VulnerabilityPage);

OrderProcessingWorker.cs (1)

66var order = JsonSerializer.Deserialize<Order>(message.Span) ?? new Order() { Id = "fake" };

GenerateTestDevCert.cs (1)

55JsonSerializer.Serialize(file, devCertJson);

DiscoverCommand.cs (1)

247JsonSerializer.Serialize(stream, tagHelpers, TagHelperDescriptorJsonConverter.SerializerOptions);

GenerateCommand.cs (1)

309var tagHelpers = JsonSerializer.Deserialize<IReadOnlyList<TagHelperDescriptor>>(stream, TagHelperDescriptorJsonConverter.SerializerOptions);

ProcessRuntimeAnalyzerVersions.cs (1)

62File.WriteAllText(path: MetadataFilePath!, JsonSerializer.Serialize(metadata, SdkTasksJsonSerializerContext.Default.DictionaryStringMetadataEntry));

JsonSchemaExporter\SchemaTestHelpers.cs (2)

69JsonSchema jsonSchema = JsonSerializer.Deserialize(schema, Context.Default.JsonSchema)!; 75JsonSerializer.Serialize(node, Context.Default.JsonNode!);

System\BinaryData.cs (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\JsonData.cs (2)

119result = JsonSerializer.Deserialize<T>(JsonBytes); 155internal static IJsonData Create<T>(T data) => new JsonData<T>() { JsonBytes = JsonSerializer.SerializeToUtf8Bytes(data) };

System\Private\Windows\Nrbf\SerializationRecordExtensions.cs (1)

621@object = (T?)JsonSerializer.Deserialize(ref reader, boundType);

System\Private\Windows\Ole\Composition.cs (3)

129/// Stores the data in the specified format using the <see cref="JsonSerializer"/>. 135/// The default behavior of <see cref="JsonSerializer"/> is used to serialize the data. 141/// for more details on default <see cref="JsonSerializer"/> behavior.

src\runtime\src\libraries\System.Text.Json\Common\JsonNumberHandling.cs (1)

7/// Determines how <see cref="JsonSerializer"/> handles numbers when serializing and deserializing.

src\runtime\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\runtime\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\FSharp\FSharpTypeConverterFactory.cs (3)

90?? JsonSerializer.TypePropertyName; 93if (!typeDiscriminatorPropertyName.Equals(JsonSerializer.TypePropertyName, StringComparison.Ordinal)) 96if ((JsonSerializer.GetMetadataPropertyName(utf8EncodedName, resolver: null) & ~MetadataPropertyName.Type) != 0)

System\Text\Json\Serialization\Converters\FSharp\FSharpUnionConverter.cs (3)

216switch (JsonSerializer.GetMetadataPropertyName(reader.GetUnescapedSpan(), resolver: null)) 315JsonSerializer.GetMetadataPropertyName(reader.GetUnescapedSpan(), resolver: null) is not MetadataPropertyName.None) 427writer.WriteString(JsonSerializer.s_metadataId, state.NewReferenceId);

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)

77if (!JsonSerializer.TryReadMetadata(this, jsonTypeInfo, ref reader, ref state)) 85value = JsonSerializer.ResolveReferenceId<T>(ref state); 108JsonSerializer.ValidateMetadataForObjectConverter(ref state); 113value = JsonSerializer.ResolveReferenceId<T>(ref state); 181ReadOnlySpan<byte> unescapedPropertyName = JsonSerializer.GetPropertyName(ref state, ref reader, options, out bool isAlreadyReadMetadataProperty); 190jsonPropertyInfo = JsonSerializer.LookupProperty( 298ReadOnlySpan<byte> unescapedPropertyName = JsonSerializer.GetPropertyName(ref state, ref reader, options, out bool isAlreadyReadMetadataProperty); 302JsonPropertyInfo jsonPropertyInfo = JsonSerializer.LookupProperty( 341JsonSerializer.WriteMetadataForObject(this, ref state, writer); 384JsonSerializer.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\Union\JsonUnionConverterFactory.cs (2)

9[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 10[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)]

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)

256[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 257[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]

System\Text\Json\Serialization\JsonConverter.MetadataHandling.cs (1)

184if (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"/>. 63if (JsonSerializer.IsReflectionEnabledByDefault)

System\Text\Json\Serialization\JsonSerializerOptions.cs (20)

System\Text\Json\Serialization\Metadata\DefaultJsonTypeInfoResolver.Converters.cs (10)

System\Text\Json\Serialization\Metadata\DefaultJsonTypeInfoResolver.cs (8)

System\Text\Json\Serialization\Metadata\DefaultJsonTypeInfoResolver.Helpers.cs (26)

System\Text\Json\Serialization\Metadata\DefaultJsonTypeInfoResolver.Union.cs (20)

System\Text\Json\Serialization\Metadata\JsonPolymorphismOptions.cs (1)

79get => _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)

346/// it has been passed to one of the <see cref="JsonSerializer"/> methods, 762if (value is not null && !JsonSerializer.IsValidNumberHandlingValue(value.Value)) 803if (value is not null && !JsonSerializer.IsValidUnmappedMemberHandlingValue(value.Value)) 847if (value is not null && !JsonSerializer.IsValidCreationHandlingValue(value.Value)) 1481[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 1482[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\MemberAccessor.cs (2)

25[RequiresUnreferencedCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 26[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]

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)

865MetadataPropertyName name = JsonSerializer.GetMetadataPropertyName(propertyName, state.Current.BaseJsonTypeInfo.PolymorphicTypeResolver);

TestProgram.cs (1)

202await Console.Out.WriteLineAsync("$ENDPOINTS: " + JsonSerializer.Serialize(root, JsonSerializerOptions.Default));