JsonSerializer

1535 references to JsonSerializer

aspire (7)

BackchannelJsonSerializerContext.BackchannelLogEntry.g.cs (1)

166global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Aspire.Cli.Backchannel.BackchannelLogEntry)value).LogLevel, LogLevel);

BackchannelJsonSerializerContext.CommandOutput.g.cs (2)

162global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Aspire.Cli.Backchannel.CommandOutput)value).LineNumber, NullableInt32); 165global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Aspire.Cli.Backchannel.CommandOutput)value).ExitCode, NullableInt32);

BackchannelJsonSerializerContext.RequestId.g.cs (1)

134global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::StreamJsonRpc.RequestId)value).Number, NullableInt64);

Commands\ExtensionInternalCommand.cs (1)

48var jsonContent = JsonSerializer.Serialize(files.Select(f => f.FullName).ToList(), BackchannelJsonSerializerContext.Default.ListString);

Configuration\ConfigurationService.cs (2)

41var jsonContent = JsonSerializer.Serialize(settings, JsonSourceGenerationContext.Default.JsonObject); 70var jsonContent = JsonSerializer.Serialize(settings, JsonSourceGenerationContext.Default.JsonObject);

Aspire.Cli.Tests (8)

Projects\ProjectLocatorTests.cs (8)

70await JsonSerializer.SerializeAsync(writer, new 109await JsonSerializer.SerializeAsync(writer, new 142await JsonSerializer.SerializeAsync(writer, new 323var settings = JsonSerializer.Deserialize<CliSettings>(settingsJson); 1014var json = JsonSerializer.Serialize(new 1049var json = JsonSerializer.Serialize(new 1088var json = JsonSerializer.Serialize(new 1155var json = JsonSerializer.Serialize(new

Aspire.Confluent.Kafka (1)

MetricsService.cs (1)

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

Aspire.Dashboard (16)

GenAIEventsContext.ToolCallFunction.g.cs (1)

110global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Arguments, JsonNode);

GenAIEventsContext.ToolEvent.g.cs (1)

110global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Content, JsonNode);

GenAIMessagesContext.DictionaryStringJsonElement.g.cs (1)

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

GenAIMessagesContext.ListMessagePart.g.cs (1)

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

GenAIMessagesContext.ToolCallRequestPart.g.cs (1)

153global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Arguments, JsonNode);

GenAIMessagesContext.ToolCallResponsePart.g.cs (1)

129global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Response, JsonNode);

Model\Assistant\AIHelpers.cs (1)

241return JsonSerializer.Serialize(value, s_jsonSerializerOptions);

Model\BrowserStorage\LocalBrowserStorage.cs (2)

36return new StorageResult<TValue>(true, JsonSerializer.Deserialize<TValue>(json, s_options)); 48var json = JsonSerializer.Serialize(value, s_options);

Model\GenAI\GenAIMessages.cs (5)

102MessagePart.TextType => JsonSerializer.Deserialize<TextPart>(doc.RootElement.GetRawText(), options), 103MessagePart.ToolCallType => JsonSerializer.Deserialize<ToolCallRequestPart>(doc.RootElement.GetRawText(), options), 104MessagePart.ToolCallResponseType => JsonSerializer.Deserialize<ToolCallResponsePart>(doc.RootElement.GetRawText(), options), 105_ => JsonSerializer.Deserialize<GenericPart>(doc.RootElement.GetRawText(), options), 111JsonSerializer.Serialize(writer, (object)value, value.GetType(), options);

Model\GenAI\GenAIVisualizerDialogViewModel.cs (1)

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

Otlp\Http\OtlpHttpEndpointsBuilder.cs (1)

115var json = JsonSerializer.Serialize(status, s_jsonOptions);

Aspire.Dashboard.Components.Tests (3)

Controls\GenAIVisualizerDialogTests.cs (3)

62var systemInstruction = JsonSerializer.Serialize(new List<MessagePart> 67var inputMessages = JsonSerializer.Serialize(new List<ChatMessage> 86var outputMessages = JsonSerializer.Serialize(new List<ChatMessage>

Aspire.Dashboard.Tests (23)

Integration\OtlpHttpServiceTests.cs (1)

279var statusResponse = JsonSerializer.Deserialize<StatusResponse>(responseBody, new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });

Model\ConsoleLogsFiltersTests.cs (2)

26var json = JsonSerializer.Serialize(filters); 27var deserialized = JsonSerializer.Deserialize<ConsoleLogsFilters>(json)!;

Model\GenAIVisualizerDialogViewModelTests.cs (15)

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

Aspire.EndToEnd.Tests (1)

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

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

Aspire.Hosting (17)

ApplicationModel\Docker\DockerfileStatements.cs (2)

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

Dashboard\DashboardEventHandlers.cs (2)

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

Dcp\DcpDependencyCheck.cs (1)

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

Dcp\DcpExecutor.cs (5)

439var serviceProducerAnnotations = JsonSerializer.Deserialize<ServiceProducerAnnotation[]>(servicesProducedAnnotationJson); 1766var current = JsonSerializer.SerializeToNode(obj); 1768var copy = JsonSerializer.Deserialize<T>(current)!; 1771var changed = JsonSerializer.SerializeToNode(copy); 2400if (_configuration[KnownConfigNames.DebugSessionInfo] is { } debugSessionInfoJson && JsonSerializer.Deserialize<RunSessionInfo>(debugSessionInfoJson) is { } debugSessionInfo)

Dcp\Model\ModelCommon.cs (4)

67Metadata.Annotations[annotationName] = JsonSerializer.Serialize<List<TValue>>(list.ToList()); 93list = JsonSerializer.Deserialize<List<TValue>>(annotationValue); 110values = JsonSerializer.Deserialize<List<TValue>>(annotationVal) ?? new(); 127var newAnnotationVal = JsonSerializer.Serialize<List<TValue>>(values);

LaunchSettingsSerializerContext.LaunchProfile.g.cs (2)

219global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Aspire.Hosting.LaunchProfile)value).DotnetRunMessages, NullableBoolean); 221global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Aspire.Hosting.LaunchProfile)value).LaunchBrowser, NullableBoolean);

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

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

Aspire.Hosting.Azure (1)

AzureBicepResource.cs (1)

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

Aspire.Hosting.Azure.Functions (3)

LaunchSettingsSerializerContext.LaunchProfile.g.cs (2)

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

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

Aspire.Hosting.Azure.ServiceBus (1)

AzureServiceBusRule.cs (1)

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

Aspire.Hosting.Azure.Tests (8)

DefaultUserPrincipalProviderTests.cs (6)

98var header = Convert.ToBase64String(Encoding.UTF8.GetBytes(JsonSerializer.Serialize(new { alg = "RS256", typ = "JWT" }))); 108var payloadJson = JsonSerializer.Serialize(payload); 121var header = Convert.ToBase64String(Encoding.UTF8.GetBytes(JsonSerializer.Serialize(new { alg = "RS256", typ = "JWT" }))); 131var payloadJson = JsonSerializer.Serialize(payload); 191var header = Convert.ToBase64String(Encoding.UTF8.GetBytes(JsonSerializer.Serialize(new { alg = "RS256", typ = "JWT" }))); 201var payloadJson = JsonSerializer.Serialize(payload);

ProvisioningTestHelpers.cs (2)

147var headerJson = JsonSerializer.Serialize(new { alg = "RS256", typ = "JWT" }); 161var payloadJson = JsonSerializer.Serialize(payload);

Aspire.Hosting.DevTunnels (1)

DevTunnelCliClient.cs (1)

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

Aspire.Hosting.GitHub.Models (2)

GitHubModelsHealthCheck.cs (2)

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

Aspire.Hosting.OpenAI (1)

OpenAIModelHealthCheck.cs (1)

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

Aspire.Hosting.Testing (3)

DistributedApplicationFactory.cs (1)

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

LaunchSettingsSerializerContext.LaunchProfile.g.cs (2)

Aspire.Hosting.Tests (18)

Dashboard\DashboardLifecycleHookTests.cs (7)

229File.WriteAllText(runtimeConfig, JsonSerializer.Serialize(originalConfig, new JsonSerializerOptions { WriteIndented = true })); 259var customConfig = JsonSerializer.Deserialize<JsonElement>(customConfigContent); 317File.WriteAllText(runtimeConfig, JsonSerializer.Serialize(originalConfig, new JsonSerializerOptions { WriteIndented = true })); 389File.WriteAllText(runtimeConfig, JsonSerializer.Serialize(originalConfig, new JsonSerializerOptions { WriteIndented = true })); 459File.WriteAllText(runtimeConfig, JsonSerializer.Serialize(originalConfig, new JsonSerializerOptions { WriteIndented = true })); 533var messageJson = JsonSerializer.Serialize(message, DashboardLogMessageContext.Default.DashboardLogMessage); 560messageJson = JsonSerializer.Serialize(message, DashboardLogMessageContext.Default.DashboardLogMessage);

Dashboard\DashboardResourceTests.cs (1)

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

Dcp\DcpExecutorTests.cs (7)

1274var serviceProducers = JsonSerializer.Deserialize<List<ServiceProducerAnnotation>>(annotations[CustomResource.ServiceProducerAnnotation]); 1559[KnownConfigNames.DebugSessionInfo] = JsonSerializer.Serialize(new RunSessionInfo { ProtocolsSupported = ["test"], SupportedLaunchConfigurations = ["test"] }), 1605[KnownConfigNames.DebugSessionInfo] = JsonSerializer.Serialize(new RunSessionInfo { ProtocolsSupported = ["test"], SupportedLaunchConfigurations = ["other_executable"] }), 1761[KnownConfigNames.DebugSessionInfo] = JsonSerializer.Serialize(runSessionInfo), 1803[KnownConfigNames.DebugSessionInfo] = JsonSerializer.Serialize(runSessionInfo), 1845[KnownConfigNames.DebugSessionInfo] = JsonSerializer.Serialize(runSessionInfo), 1962[KnownConfigNames.DebugSessionInfo] = JsonSerializer.Serialize(runSessionInfo),

Dcp\TestKubernetesService.cs (2)

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

LaunchSettingsSerializerContextTests.cs (1)

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

Aspire.Hosting.Yarp (3)

YarpJsonConfigGeneratorBuilder.cs (3)

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

Aspire.Templates.Tests (1)

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

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

AzureSearch.ApiService (1)

Program.cs (1)

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

BasketService (3)

BasketService.cs (1)

88body: JsonSerializer.SerializeToUtf8Bytes(order));

Repositories\RedisBasketRepository.cs (2)

39return JsonSerializer.Deserialize<CustomerBasket>(data.ToString(), s_jsonSerializerOptions); 49var created = await _database.StringSetAsync(basket.BuyerId, JsonSerializer.Serialize(basket, s_jsonSerializerOptions));

BicepSample.ApiService (5)

Program.cs (5)

104await database.ListRightPushAsync("entries", JsonSerializer.SerializeToUtf8Bytes(entry)); 111entries.Add(JsonSerializer.Deserialize<Entry>((string)item!)!); 135entries.Add(JsonSerializer.Deserialize<Entry>(content)!); 151{ "data", JsonSerializer.Serialize(entry) } 160entries.Add(JsonSerializer.Deserialize<Entry>((string)item["data"])!);

CdkSample.ApiService (2)

Program.cs (2)

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

ConfigurationSchemaGenerator (1)

ConfigSchemaEmitter.cs (1)

48return JsonSerializer.Serialize(root, s_serializerOptions);

dotnet (38)

CliSchema.cs (1)

73var result = JsonSerializer.Serialize(transportStructure, s_jsonSerializerOptions);

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

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

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

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

Commands\Run\CSharpCompilerCommand.cs (3)

288"version": {{JsonSerializer.Serialize(RuntimeVersion)}} 291"EntryPointFilePath": {{JsonSerializer.Serialize(EntryPointFileFullPath)}}, 292"EntryPointFileDirectoryPath": {{JsonSerializer.Serialize(fileDirectory)}},

Commands\Run\VirtualProjectBuildingCommand.cs (2)

873return JsonSerializer.Deserialize(stream, RunFileJsonSerializerContext.Default.RunFileBuildCacheEntry); 1037JsonSerializer.Serialize(stream, cache.CurrentEntry, RunFileJsonSerializerContext.Default.RunFileBuildCacheEntry);

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

32_sdkCheckConfig = File.Exists(configFilePath) ? JsonSerializer.Deserialize<SdkCheckConfig>(File.ReadAllText(configFilePath)) : null;

Commands\Test\TestCommandParser.cs (1)

193var globalJson = JsonSerializer.Deserialize<GlobalJsonModel>(jsonText, new JsonSerializerOptions()

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

130var jsonText = System.Text.Json.JsonSerializer.Serialize(jsonData, JsonHelper.NoEscapeSerializerOptions);

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

102var jsonText = System.Text.Json.JsonSerializer.Serialize(jsonData, JsonHelper.NoEscapeSerializerOptions);

Commands\Workload\GlobalJsonWorkloadSetFile.cs (4)

31globalJsonWorkloadSetVersions = JsonSerializer.Deserialize<Dictionary<string, string>>(fileStream, _jsonSerializerOptions); 39JsonSerializer.Serialize(fileStream, globalJsonWorkloadSetVersions, _jsonSerializerOptions); 69var globalJsonWorkloadSetVersions = JsonSerializer.Deserialize<Dictionary<string, string>>(fileStream, _jsonSerializerOptions); 89JsonSerializer.Serialize(fileStream, globalJsonWorkloadSetVersions, _jsonSerializerOptions);

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

542var packToDelete = JsonSerializer.Deserialize<PackInfo>(jsonPackInfo); 634File.WriteAllText(logFile, JsonSerializer.Serialize(workloadHistoryRecord, new JsonSerializerOptions() { WriteIndented = true })); 877File.WriteAllText(path, JsonSerializer.Serialize(packInfo));

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

385File.WriteAllText(logFile, JsonSerializer.Serialize(workloadHistoryRecord, new JsonSerializerOptions() { WriteIndented = true }));

Commands\Workload\Install\NetSdkMsiInstallerClient.PackGroup.cs (1)

45var packGroups = JsonSerializer.Deserialize<IList<WorkloadPackGroupJson>>(File.ReadAllText(packGroupFile));

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

132Reporter.WriteLine(JsonSerializer.Serialize(packageUrls, new JsonSerializerOptions() { WriteIndented = true }));

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

140var jsonContent = JsonSerializer.Serialize(updatableWorkloads.Select(workload => workload.ToString()).ToArray()); 166var updatableWorkloads = JsonSerializer.Deserialize<string[]>(File.ReadAllText(adUpdatesFile));

Commands\Workload\InstallStateContents.cs (2)

35return JsonSerializer.Deserialize<InstallStateContents>(contents, s_options) ?? new InstallStateContents(); 45return JsonSerializer.Serialize(this, s_options);

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

74Reporter.WriteLine(JsonSerializer.Serialize(listOutput, new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase }));

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

99Reporter.WriteLine(JsonSerializer.Serialize(versions.Select(version => new Dictionary<string, string>() 123Reporter.WriteLine(JsonSerializer.Serialize(versions.Select(version => version.ToDictionary(_ => "workloadVersion", v => v)))); 136Reporter.WriteLine(JsonSerializer.Serialize(new Dictionary<string, Dictionary<string, string>>()

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

96Reporter.WriteLine(JsonSerializer.Serialize(packageUrls, new JsonSerializerOptions() { WriteIndented = true }));

NugetSearch\NugetSearchApiResultDeserializer.cs (1)

24var deserialized = JsonSerializer.Deserialize<NugetSearchApiContainerSerializable>(json, options);

ToolPackage\LocalToolsResolverCache.cs (3)

52JsonSerializer.Serialize(existingCacheTable.Concat(diffedRow))); 65JsonSerializer.Serialize(rowsToAdd)); 97JsonSerializer.Deserialize<CacheRow[]>(_fileSystem.File.ReadAllText(packageCacheFile));

WorkloadFileBasedInstall.cs (1)

61var historyRecord = JsonSerializer.Deserialize<WorkloadHistoryRecord>(File.ReadAllText(file));

dotnet.Tests (15)

CommandTests\Run\RunFileTests.cs (1)

3195private static string ToJson(string s) => JsonSerializer.Serialize(s);

CommandTests\Sdk\Check\GivenDotnetSdkCheck.cs (1)

199var configFileContent = JsonSerializer.Serialize(new SdkCheckConfig() { CommandOutputReplacementString = replacementString });

CommandTests\Tool\Install\ToolInstallGlobalOrToolPathCommandTests.cs (2)

150var deserializedFakeShim = JsonSerializer.Deserialize<AppHostShellShimMakerMock.FakeShim>( 217JsonSerializer.Deserialize<AppHostShellShimMakerMock.FakeShim>(

CommandTests\Tool\List\ToolListGlobalOrToolPathCommandTests.cs (1)

185var versionedData = System.Text.Json.JsonSerializer.Deserialize<VersionedDataContract<ToolListJsonContract[]>>(_reporter.Lines[0]);

CommandTests\Tool\List\ToolListLocalCommandTests.cs (1)

81var versionedData = JsonSerializer.Deserialize<VersionedDataContract<LocalToolListJsonContract[]>>(_reporter.Lines[0]);

CommandTests\Tool\Restore\ToolRestoreCommandTests.cs (1)

429var rows = JsonSerializer.Deserialize<List<CacheRow>>(json);

CommandTests\Workload\Clean\GivenDotnetWorkloadClean.cs (1)

149var packRecordContents = JsonSerializer.Serialize<WorkloadResolver.PackInfo>(new(new WorkloadPackId("Test.Pack.A"), "1.0.0", WorkloadPackKind.Sdk, packPath, "Test.Pack.A"));

CommandTests\Workload\Install\GivenFileBasedWorkloadInstall.cs (1)

286var packRecordContents = JsonSerializer.Serialize<WorkloadResolver.PackInfo>(pack);

CommandTests\Workload\Install\GivenWorkloadManifestUpdater.cs (3)

439var rollbackDefContent = JsonSerializer.Serialize(new Dictionary<string, string>() { { "test-manifest-1", "4.0.0" }, { "test-manifest-2", "2.0.0" } }); 481var rollbackDefContent = JsonSerializer.Serialize(new Dictionary<string, string>() { { "test-manifest-1", "4.0.0" }, { "test-manifest-2", "2.0.0" } }); 520var rollbackDefContent = JsonSerializer.Serialize(new Dictionary<string, string>() {

CommandTests\Workload\Install\WorkloadGarbageCollectionTests.cs (1)

326var packRecordContents = JsonSerializer.Serialize<WorkloadResolver.PackInfo>(pack);

CommandTests\Workload\Repair\GivenDotnetWorkloadRepair.cs (1)

91var packRecordContents = JsonSerializer.Serialize<WorkloadResolver.PackInfo>(new(new WorkloadPackId("Test.Pack.A"), "1.0.0", WorkloadPackKind.Sdk, extraPackPath, "Test.Pack.A"));

CommandTests\Workload\Update\GivenDotnetWorkloadUpdate.cs (1)

87records: new List<WorkloadHistoryRecord>() { JsonSerializer.Deserialize<WorkloadHistoryRecord>(workloadHistoryRecord) })

dotnet-dev-certs (1)

Program.cs (1)

367reporter.Output(JsonSerializer.Serialize(certReports, options: new JsonSerializerOptions { WriteIndented = true }));

dotnet-format (1)

ReportWriter.cs (1)

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

dotnet-MsiInstallation.Tests (5)

Framework\VirtualMachine.cs (3)

47VMTestSettings = JsonSerializer.Deserialize<VMTestSettings>(json); 86_vmState = JsonSerializer.Deserialize<SerializableVMState>(json, GetSerializerOptions()).ToVMState(); 124string json = JsonSerializer.Serialize(_vmState.ToSerializable(), GetSerializerOptions());

WorkloadSetTests.cs (1)

362var searchResultWorkloadSet = WorkloadSet.FromDictionaryForJson(JsonSerializer.Deserialize<Dictionary<string, string>>(searchResultJson["manifestVersions"]), new SdkFeatureBand(SdkInstallerVersion));

WorkloadSetTestsBase.cs (1)

35return JsonSerializer.Deserialize<Dictionary<string, string>>(versionsFile.ReadAllText());

dotnet-new.IntegrationTests (2)

DotnetNewTestTemplatesTests.cs (2)

250manifest = JsonSerializer.Deserialize<ComponentDetectionManifest>(jsonContent) ?? 340JsonSerializer.Serialize(manifest, new JsonSerializerOptions

dotnet-user-jwts (12)

Commands\CreateCommand.cs (1)

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

Commands\ListCommand.cs (2)

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

Helpers\DevJwtCliHelpers.cs (1)

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

Helpers\JwtAuthenticationSchemeSettings.cs (4)

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

Helpers\JwtStore.cs (2)

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

Helpers\SigningKeysHandler.cs (2)

71secrets = JsonSerializer.Deserialize<JsonObject>(secretsFileStream, JwtSerializerOptions.Default); 96JsonSerializer.Serialize(secretsWriteStream, secrets);

dotnet-watch (6)

AbstractBrowserRefreshServer.cs (3)

225=> JsonSerializer.SerializeToUtf8Bytes(value, s_jsonSerializerOptions); 228=> JsonSerializer.Deserialize<TValue>(value, s_jsonSerializerOptions) ?? throw new InvalidDataException("Unexpected null object"); 314var message = JsonSerializer.SerializeToUtf8Bytes(new UpdateStaticFileMessage { Path = relativeUrl }, s_jsonSerializerOptions);

AspireServerService.cs (1)

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

Process\LaunchSettingsProfile.cs (1)

60launchSettings = JsonSerializer.Deserialize<LaunchSettingsJson>(

Watch\MsBuildFileSetFactory.cs (1)

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

dotnet-watch.Tests (2)

Build\FileSetSerializerTests.cs (2)

66var result2 = await JsonSerializer.DeserializeAsync<MSBuildFileSetResult>(stream1, cancellationToken: CancellationToken.None); 181var value = await JsonSerializer.DeserializeAsync<MSBuildFileSetResult>(stream, cancellationToken: CancellationToken.None);

IdentitySample.PasskeyConformance (4)

Program.cs (4)

71var stateJson = JsonSerializer.Serialize(state, JsonSerializerOptions.Web); 90var state = JsonSerializer.Deserialize<PasskeyAttestationState>(stateJson, JsonSerializerOptions.Web); 160var stateJson = JsonSerializer.Serialize(state, JsonSerializerOptions.Web); 177var state = JsonSerializer.Deserialize<PasskeyAssertionState>(stateJson, JsonSerializerOptions.Web);

InMemory.FunctionalTests (1)

EventSourceTests.cs (1)

460_logger?.LogInformation("{event}", JsonSerializer.Serialize(eventData, new JsonSerializerOptions

Microsoft.AspNetCore.Authentication.Core.Test (4)

AuthenticationPropertiesTests.cs (4)

321var json = JsonSerializer.Serialize(props); 328var deserialized = JsonSerializer.Deserialize<AuthenticationProperties>(json); 352var deserialized = JsonSerializer.Deserialize<AuthenticationProperties>(json); 376var json = JsonSerializer.Serialize(props, options);

Microsoft.AspNetCore.Authentication.JwtBearer.Tools.Tests (13)

UserJwtsTests.cs (13)

Microsoft.AspNetCore.Authentication.Test (1)

OAuthTests.cs (1)

543var text = JsonSerializer.Serialize(content);

Microsoft.AspNetCore.Authentication.Twitter (1)

TwitterHandler.cs (1)

371errorResponse = await JsonSerializer.DeserializeAsync(errorContentStream, TwitterJsonContext.DefaultWithOptions.TwitterErrorResponse);

Microsoft.AspNetCore.Components (4)

PersistentComponentState.cs (4)

118if (!_currentState.TryAdd(key, JsonSerializer.SerializeToUtf8Bytes(instance, JsonSerializerOptionsProvider.Options))) 134if (!_currentState.TryAdd(key, JsonSerializer.SerializeToUtf8Bytes(instance, type, JsonSerializerOptionsProvider.Options))) 177instance = JsonSerializer.Deserialize<TValue>(ref reader, JsonSerializerOptionsProvider.Options)!; 195instance = JsonSerializer.Deserialize(ref reader, type, JsonSerializerOptionsProvider.Options);

Microsoft.AspNetCore.Components.Endpoints (11)

Assets\ImportMapDefinition.cs (1)

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

Builder\ResourceCollectionUrlEndpoint.cs (1)

100JsonSerializer.Serialize<IReadOnlyList<ResourceAsset>>(utf8Writer, resourceCollection, ResourceCollectionSerializerContext.Default.Options);

DependencyInjection\DefaultRazorComponentsServiceOptionsConfiguration.cs (1)

57var initializers = JsonSerializer.Deserialize<string[]>(options.JavaScriptInitializers);

DependencyInjection\WebAssemblyComponentSerializer.cs (2)

19var serializedDefinitions = Convert.ToBase64String(JsonSerializer.SerializeToUtf8Bytes(definitions, WebAssemblyComponentSerializationSettings.JsonSerializationOptions)); 20var serializedValues = Convert.ToBase64String(JsonSerializer.SerializeToUtf8Bytes(values, WebAssemblyComponentSerializationSettings.JsonSerializationOptions));

Rendering\EndpointHtmlRenderer.Streaming.cs (3)

291var settingsJson = JsonSerializer.Serialize(settings, ServerComponentSerializationSettings.JsonSerializationOptions); 296var serializedStartRecord = JsonSerializer.Serialize(marker, ServerComponentSerializationSettings.JsonSerializationOptions); 320var serializedEndRecord = JsonSerializer.Serialize(endMarker, ServerComponentSerializationSettings.JsonSerializationOptions);

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

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

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

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

Microsoft.AspNetCore.Components.Endpoints.Tests (46)

EndpointHtmlRendererTest.cs (45)

WebRootComponentParametersTest.cs (1)

179var jsonElement = JsonSerializer.SerializeToElement(parameterValues[i]);

Microsoft.AspNetCore.Components.Server (14)

CircuitPersistenceManagerSerializerContext.ComponentMarker.g.cs (2)

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

172return JsonSerializer.Deserialize<Dictionary<int, ComponentMarker>>( 209RootComponents = JsonSerializer.SerializeToUtf8Bytes(

Circuits\ComponentParameterDeserializer.cs (1)

65var parameterValue = JsonSerializer.Deserialize(

Circuits\ServerComponentDeserializer.cs (3)

96var markers = JsonSerializer.Deserialize<IEnumerable<ComponentMarker>>(serializedComponentRecords, ServerComponentSerializationSettings.JsonSerializationOptions); 259result = JsonSerializer.Deserialize<ServerComponent>( 302result = JsonSerializer.Deserialize<RootComponentOperationBatch>(

ProtectedBrowserStorage\ProtectedBrowserStorage.cs (2)

125var json = JsonSerializer.Serialize(value, options: JsonSerializerOptionsProvider.Options); 136return JsonSerializer.Deserialize<TValue>(json, options: JsonSerializerOptionsProvider.Options)!;

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

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

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

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

Microsoft.AspNetCore.Components.Server.Tests (7)

Circuits\CircuitHostTest.cs (1)

894var jsonElement = JsonSerializer.SerializeToElement(parameterValues[i]);

Circuits\CircuitPersistenceManagerTest.cs (2)

374var actual = JsonSerializer.Deserialize<Dictionary<int, ComponentMarker>>(rootComponents, SerializerOptions); 559var batchJson = JsonSerializer.Serialize(batch, ServerComponentSerializationSettings.JsonSerializationOptions);

Circuits\RemoteRendererTest.cs (1)

695var jsonElement = JsonSerializer.SerializeToElement(parameterValues[i]);

Circuits\ServerComponentDeserializerTest.cs (3)

427JsonSerializer.Serialize( 432=> JsonSerializer.Serialize(batch, ServerComponentSerializationSettings.JsonSerializationOptions); 444JsonSerializer.Serialize(markers, ServerComponentSerializationSettings.JsonSerializationOptions);

Microsoft.AspNetCore.Components.Tests (33)

BindConverterTest.cs (3)

292var expected = JsonSerializer.Serialize(value); 404return JsonSerializer.Deserialize<Person>(text); 424return JsonSerializer.Serialize((Person)value);

PersistentState\ComponentStatePersistenceManagerTest.cs (3)

46["MyState"] = JsonSerializer.SerializeToUtf8Bytes(data) 131var registration = Assert.Single(JsonSerializer.Deserialize<PersistentService[]>(registrations, JsonSerializerOptions.Web)); 160Assert.Equal(data, JsonSerializer.Deserialize<byte[]>(persisted.ToArray()));

PersistentState\PersistentComponentStateTest.cs (7)

21["MyState"] = JsonSerializer.SerializeToUtf8Bytes(new byte[] { 1, 2, 3, 4 }) 69["MyState"] = JsonSerializer.SerializeToUtf8Bytes(new byte[] { 1, 2, 3, 4 }) 97Assert.Equal(myState, JsonSerializer.Deserialize<byte[]>(stored)); 133Assert.Equal(myState, JsonSerializer.Deserialize<byte[]>(stored)); 151Assert.Null(JsonSerializer.Deserialize<byte[]>(stored)); 159var serialized = JsonSerializer.SerializeToUtf8Bytes(myState); 177var serialized = JsonSerializer.SerializeToUtf8Bytes<byte[]>(null);

PersistentStateValueProviderTests.cs (1)

108dictionary[key] = JsonSerializer.SerializeToUtf8Bytes(item.value, JsonSerializerOptions.Web);

PersistentValueProviderComponentSubscriptionTests.cs (13)

ResourceAssetCollectionTest.cs (6)

100var json = JsonSerializer.Serialize(originalAsset, options); 101var deserializedAsset = JsonSerializer.Deserialize<ResourceAsset>(json, options); 121var json = JsonSerializer.Serialize(originalAsset, options); 122var deserializedAsset = JsonSerializer.Deserialize<ResourceAsset>(json, options); 146var json = JsonSerializer.Serialize<IReadOnlyList<ResourceAsset>>(assets, options); 147var deserializedAssets = JsonSerializer.Deserialize<IReadOnlyList<ResourceAsset>>(json, options);

Microsoft.AspNetCore.Components.Web (5)

JSComponents\JSComponentInterop.cs (3)

104ParameterKind.Value => JsonSerializer.Deserialize( 109JsonSerializer.Deserialize<IJSObjectReference>(parameterJsonValue, jsonOptions)), 112JsonSerializer.Deserialize<IJSObjectReference>(parameterJsonValue, jsonOptions)),

WebEventData\WebEventData.cs (1)

79return (EventArgs)JsonSerializer.Deserialize(eventArgsJson.GetRawText(), eventArgsType, jsonSerializerOptions)!;

WebRenderer.cs (1)

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

Microsoft.AspNetCore.Components.Web.Tests (12)

WebEventData\ChangeEventArgsReaderTest.cs (1)

65var json = JsonSerializer.SerializeToUtf8Bytes(args, JsonSerializerOptionsProvider.Options);

WebEventData\ClipboardEventArgsReaderTest.cs (1)

29var json = JsonSerializer.SerializeToUtf8Bytes(args, JsonSerializerOptionsProvider.Options);

WebEventData\DragEventArgsReaderTest.cs (1)

83var json = JsonSerializer.SerializeToUtf8Bytes(args, JsonSerializerOptionsProvider.Options);

WebEventData\ErrorEventArgsReaderTest.cs (1)

38var json = JsonSerializer.SerializeToUtf8Bytes(args, JsonSerializerOptionsProvider.Options);

WebEventData\FocusEventArgsReaderTest.cs (1)

30var json = JsonSerializer.SerializeToUtf8Bytes(args, JsonSerializerOptionsProvider.Options);

WebEventData\KeyboardEventArgsReaderTest.cs (1)

48var json = JsonSerializer.SerializeToUtf8Bytes(args, JsonSerializerOptionsProvider.Options);

WebEventData\MouseEventArgsReaderTest.cs (1)

68var json = JsonSerializer.SerializeToUtf8Bytes(args, JsonSerializerOptionsProvider.Options);

WebEventData\PointerEventArgsReaderTest.cs (1)

60var json = JsonSerializer.SerializeToUtf8Bytes(args, JsonSerializerOptionsProvider.Options);

WebEventData\ProgressEventArgsReaderTest.cs (1)

35var json = JsonSerializer.SerializeToUtf8Bytes(args, JsonSerializerOptionsProvider.Options);

WebEventData\TouchEventArgsReaderTest.cs (1)

113var json = JsonSerializer.SerializeToUtf8Bytes(args, JsonSerializerOptionsProvider.Options);

WebEventData\WebEventDescriptorReaderTest.cs (1)

67var json = JsonSerializer.SerializeToUtf8Bytes(args, JsonSerializerOptionsProvider.Options);

WebEventData\WheelEventArgsReaderTest.cs (1)

53var json = JsonSerializer.SerializeToUtf8Bytes(args, JsonSerializerOptionsProvider.Options);

Microsoft.AspNetCore.Components.WebAssembly (10)

Prerendering\WebAssemblyComponentParameterDeserializer.cs (3)

60var parameterValue = JsonSerializer.Deserialize( 81return JsonSerializer.Deserialize(parametersDefinitions, WebAssemblyJsonSerializerContext.Default.ComponentParameterArray)!; 87return JsonSerializer.Deserialize(parameterValues, WebAssemblyJsonSerializerContext.Default.IListObject)!;

Services\DefaultWebAssemblyJSRuntime.cs (1)

117var deserialized = JsonSerializer.Deserialize(

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

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

WebAssemblyJsonSerializerContext.ComponentMarker.g.cs (2)

251global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Key, NullableComponentMarkerKey); 257global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Sequence, NullableInt32);

WebAssemblyJsonSerializerContext.RootComponentOperation.g.cs (2)

144global::System.Text.Json.JsonSerializer.Serialize(writer, ((global::Microsoft.AspNetCore.Components.RootComponentOperation)value).Type, RootComponentOperationType); 150global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Marker, NullableComponentMarker);

Microsoft.AspNetCore.Components.WebAssembly.Server (2)

TargetPickerUi.cs (2)

53var msg = JsonSerializer.Serialize(args); 448return JsonSerializer.Deserialize<BrowserTab[]>(jsonResponse, JsonOptions)!;

Microsoft.AspNetCore.Components.WebAssembly.Tests (3)

JSObjectReferenceJsonConverterTest.cs (3)

28var deserialized = (JSObjectReference)JsonSerializer.Deserialize<IJSObjectReference>(json, JsonSerializerOptions)!; 42var deserialized = (JSInProcessObjectReference)JsonSerializer.Deserialize<IJSInProcessObjectReference>(json, JsonSerializerOptions)!; 55var deserialized = JsonSerializer.Deserialize<IJSObjectReference>(json, JsonSerializerOptions);

Microsoft.AspNetCore.Components.WebView (7)

IpcCommon.cs (2)

34return $"{_ipcMessagePrefix}{JsonSerializer.Serialize(messageTypeAndArgs, JsonSerializerOptionsProvider.Options)}"; 44var parsed = (JsonElement[])JsonSerializer.Deserialize(messageAfterPrefix, typeof(JsonElement[]), JsonSerializerOptionsProvider.Options);

SourceGenerationContext.DictionaryStringStaticWebAssetNode.g.cs (1)

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

SourceGenerationContext.IDictionaryStringStaticWebAssetNode.g.cs (1)

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

SourceGenerationContext.StaticWebAssetManifest.g.cs (1)

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

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

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

Microsoft.AspNetCore.Diagnostics (2)

DeveloperExceptionPage\DeveloperExceptionPageMiddlewareImpl.cs (1)

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

ExtensionsExceptionJsonContext.ExceptionExtensionData.g.cs (1)

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

Microsoft.AspNetCore.Grpc.JsonTranscoding (17)

Internal\Json\AnyConverter.cs (5)

50data = (IMessage)JsonSerializer.Deserialize(valueField, descriptor.ClrType, options)!; 54data = (IMessage)JsonSerializer.Deserialize(d.RootElement, descriptor.ClrType, options)!; 89JsonSerializer.Serialize(writer, wrappedValue, wrappedValue.GetType(), options); 93JsonSerializer.Serialize(writer, valueMessage, valueMessage.GetType(), options); 118JsonSerializer.Serialize(writer, value, value.GetType(), options);

Internal\Json\JsonConverterHelper.cs (2)

140var newValues = (IDictionary)JsonSerializer.Deserialize(ref reader, repeatedFieldType, options)!; 154var newValues = (IList)JsonSerializer.Deserialize(ref reader, repeatedFieldType, options)!;

Internal\Json\ListValueConverter.cs (1)

30JsonSerializer.Serialize(writer, list, list.GetType(), options);

Internal\Json\StructConverter.cs (1)

41JsonSerializer.Serialize(writer, v, v.GetType(), options);

Internal\Json\ValueConverter.cs (3)

28var structMessage = JsonSerializer.Deserialize(ref reader, field.MessageType.ClrType, options); 35var list = JsonSerializer.Deserialize(ref reader, field.MessageType.ClrType, options); 80JsonSerializer.Serialize(writer, v, v.GetType(), options);

Internal\Json\WrapperConverter.cs (2)

21var value = JsonSerializer.Deserialize(ref reader, t, options); 31JsonSerializer.Serialize(writer, innerValue, innerValue.GetType(), options);

Internal\JsonRequestHelpers.cs (3)

172await JsonSerializer.SerializeAsync(stream, responseBody, options, cancellationToken); 233bodyContent = (await JsonSerializer.DeserializeAsync(stream, type, serializerOptions))!; 245bodyContent = (IMessage)(await JsonSerializer.DeserializeAsync(stream, serverCallContext.DescriptorInfo.BodyDescriptor.ClrType, serializerOptions))!;

Microsoft.AspNetCore.Grpc.JsonTranscoding.Tests (5)

ConverterTests\JsonConverterReadTests.cs (2)

857var objectNew = JsonSerializer.Deserialize<TValue>(value, jsonSerializerOptions)!; 885var ex = Assert.ThrowsAny<Exception>(() => JsonSerializer.Deserialize<TValue>(value, jsonSerializerOptions));

ConverterTests\JsonConverterWriteTests.cs (3)

250var json = JsonSerializer.Serialize(v, jsonSerializerOptions); 265var json = JsonSerializer.Serialize(v, jsonSerializerOptions); 611var jsonNew = JsonSerializer.Serialize(value, jsonSerializerOptions);

Microsoft.AspNetCore.Grpc.Microbenchmarks (2)

Json\JsonReading.cs (1)

35JsonSerializer.Deserialize(_requestJson, typeof(HelloRequest), _serializerOptions);

Json\JsonWriting.cs (1)

36JsonSerializer.Serialize(_request, _serializerOptions);

Microsoft.AspNetCore.Hosting (5)

SourceGenerationContext.DictionaryStringStaticWebAssetNode.g.cs (1)

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

SourceGenerationContext.IDictionaryStringStaticWebAssetNode.g.cs (1)

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

SourceGenerationContext.StaticWebAssetManifest.g.cs (1)

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

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

Microsoft.AspNetCore.Http.Abstractions.Tests (12)

HttpValidationProblemDetailsJsonConverterTest.cs (4)

30JsonSerializer.Serialize(writer, problemDetails, JsonSerializerOptions); 63var problemDetails = JsonSerializer.Deserialize<HttpValidationProblemDetails>(ref reader, JsonSerializerOptions); 106var problemDetails = JsonSerializer.Deserialize<HttpValidationProblemDetails>(ref reader, JsonSerializerOptions); 145var problemDetails = JsonSerializer.Deserialize<HttpValidationProblemDetails>(json, JsonSerializerOptions);

ProblemDetailsJsonConverterTest.cs (8)

26JsonSerializer.Deserialize(ref reader, typeof(ProblemDetails), JsonSerializerOptions); 46var problemDetails = JsonSerializer.Deserialize<ProblemDetails>(ref reader, JsonSerializerOptions); 77var problemDetails = JsonSerializer.Deserialize<ProblemDetails>(json, JsonSerializerOptions); 109var problemDetails = JsonSerializer.Deserialize<ProblemDetails>(json, serializerOptions); 141var problemDetails = JsonSerializer.Deserialize<ProblemDetails>(ref reader, JsonSerializerOptions); 181JsonSerializer.Serialize(writer, value, JsonSerializerOptions); 205JsonSerializer.Serialize(writer, value, JsonSerializerOptions); 236JsonSerializer.Serialize(writer, value, JsonSerializerOptions);

Microsoft.AspNetCore.Http.Extensions (26)

HttpRequestJsonExtensions.cs (15)

HttpResponseJsonExtensions.cs (10)

JsonOptions.cs (1)

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

Microsoft.AspNetCore.Http.Microbenchmarks (3)

src\Http\Http.Extensions\test\RequestDelegateGenerator\RequestDelegateCreationTestBase.cs (2)

225var requestBodyBytes = JsonSerializer.SerializeToUtf8Bytes(requestData); 243var deserializedObject = JsonSerializer.Deserialize<T>(body, new JsonSerializerOptions()

src\Http\Http.Extensions\test\RequestDelegateGenerator\SharedTypes.cs (1)

92var body = await JsonSerializer.DeserializeAsync<JsonTodo>(context.Request.Body);

Microsoft.AspNetCore.Http.Results (1)

ServerSentEventsResult.cs (1)

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

Microsoft.AspNetCore.Http.Results.Tests (19)

HttpResultsHelperTests.cs (6)

40var body = JsonSerializer.Deserialize<TodoStruct>(responseBodyStream.ToArray(), serializerOptions); 71var body = JsonSerializer.Deserialize<Todo>(responseBodyStream.ToArray(), serializerOptions); 104var body = JsonSerializer.Deserialize<TodoChild>(responseBodyStream.ToArray(), serializerOptions); 138var body = JsonSerializer.Deserialize<TodoChild>(responseBodyStream.ToArray(), serializerOptions); 172var body = JsonSerializer.Deserialize<TodoJsonChild>(responseBodyStream.ToArray(), serializerOptions); 200var body = JsonSerializer.Deserialize<JsonTodo[]>(responseBodyStream.ToArray(), serializerOptions);

JsonResultTests.cs (5)

108var responseDetails = JsonSerializer.Deserialize<Todo>(stream); 114Assert.Equal(JsonSerializer.Serialize(value, options: jsonOptions), Encoding.UTF8.GetString(stream.ToArray())); 140var responseDetails = JsonSerializer.Deserialize<ProblemDetails>(stream, JsonSerializerOptions.Web); 169var responseDetails = JsonSerializer.Deserialize<HttpValidationProblemDetails>(stream, JsonSerializerOptions.Web); 201var responseDetails = JsonSerializer.Deserialize<HttpValidationProblemDetails>(stream, JsonSerializerOptions.Web);

ProblemResultTests.cs (5)

38var responseDetails = JsonSerializer.Deserialize<ProblemDetails>(stream, JsonSerializerOptions.Web); 70var responseDetails = JsonSerializer.Deserialize<ProblemDetails>(stream, JsonSerializerOptions.Web); 99var responseDetails = JsonSerializer.Deserialize<HttpValidationProblemDetails>(stream, JsonSerializerOptions.Web); 131var responseDetails = JsonSerializer.Deserialize<HttpValidationProblemDetails>(stream, JsonSerializerOptions.Web); 163var responseDetails = JsonSerializer.Deserialize<HttpValidationProblemDetails>(stream, JsonSerializerOptions.Web);

TestJsonContext.JsonTodoArray.g.cs (1)

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

ValidationProblemResultTests.cs (2)

42var responseDetails = JsonSerializer.Deserialize<ProblemDetails>(stream, JsonSerializerOptions.Web); 74var responseDetails = JsonSerializer.Deserialize<ProblemDetails>(stream, JsonSerializerOptions.Web);

Microsoft.AspNetCore.Identity (33)

IdentityEndpointsJsonSerializerContext.TwoFactorRequest.g.cs (1)

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

IdentityJsonSerializerContext.AuthenticatorAssertionResponse.g.cs (4)

156global::System.Text.Json.JsonSerializer.Serialize(writer, __value_AuthenticatorData, BufferSource); 162global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Signature, BufferSource); 168global::System.Text.Json.JsonSerializer.Serialize(writer, __value_UserHandle, BufferSource); 174global::System.Text.Json.JsonSerializer.Serialize(writer, __value_ClientDataJSON, BufferSource);

IdentityJsonSerializerContext.AuthenticatorAttestationResponse.g.cs (2)

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

IdentityJsonSerializerContext.CollectedClientData.g.cs (2)

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

IdentityJsonSerializerContext.PasskeyAssertionState.g.cs (1)

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

IdentityJsonSerializerContext.PasskeyAttestationState.g.cs (1)

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

IdentityJsonSerializerContext.PublicKeyCredentialAuthenticatorAssertionResponse.g.cs (2)

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

IdentityJsonSerializerContext.PublicKeyCredentialAuthenticatorAttestationResponse.g.cs (2)

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

IdentityJsonSerializerContext.PublicKeyCredentialCreationOptions.g.cs (3)

316global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Challenge, BufferSource); 328global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Timeout, NullableUInt64); 363global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Extensions, NullableJsonElement);

IdentityJsonSerializerContext.PublicKeyCredentialDescriptor.g.cs (1)

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

IdentityJsonSerializerContext.PublicKeyCredentialParameters.g.cs (1)

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

IdentityJsonSerializerContext.PublicKeyCredentialRequestOptions.g.cs (3)

214global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Challenge, BufferSource); 220global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Timeout, NullableUInt64); 248global::System.Text.Json.JsonSerializer.Serialize(writer, __value_Extensions, NullableJsonElement);

IdentityJsonSerializerContext.PublicKeyCredentialUserEntity.g.cs (1)

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

PasskeyHandler.cs (9)

79var optionsJson = JsonSerializer.Serialize(options, IdentityJsonSerializerContext.Default.PublicKeyCredentialCreationOptions); 80var attestationStateJson = JsonSerializer.Serialize(attestationState, IdentityJsonSerializerContext.Default.PasskeyAttestationState); 131var optionsJson = JsonSerializer.Serialize(options, IdentityJsonSerializerContext.Default.PublicKeyCredentialRequestOptions); 132var assertionStateJson = JsonSerializer.Serialize(assertionState, IdentityJsonSerializerContext.Default.PasskeyAssertionState); 224credential = JsonSerializer.Deserialize(context.CredentialJson, IdentityJsonSerializerContext.Default.PublicKeyCredentialAuthenticatorAttestationResponse) 239attestationState = JsonSerializer.Deserialize(attestationStateJson, IdentityJsonSerializerContext.Default.PasskeyAttestationState) 379credential = JsonSerializer.Deserialize(context.CredentialJson, IdentityJsonSerializerContext.Default.PublicKeyCredentialAuthenticatorAssertionResponse) 394assertionState = JsonSerializer.Deserialize(assertionStateJson, IdentityJsonSerializerContext.Default.PasskeyAssertionState) 575clientData = JsonSerializer.Deserialize(utf8Json.Span, IdentityJsonSerializerContext.Default.CollectedClientData)

Microsoft.AspNetCore.Identity.Test (3)

Passkeys\PasskeyHandlerAssertionTest.cs (1)

1056var requestOptions = JsonSerializer.Deserialize(

Passkeys\PasskeyHandlerAttestationTest.cs (1)

1035var creationOptions = JsonSerializer.Deserialize(

Passkeys\PasskeyScenarioTest.cs (1)

93_jsonElementValue = JsonSerializer.Deserialize<JsonElement>(rawValue, _jsonSerializerOptions);

Microsoft.AspNetCore.Identity.UI (2)

Areas\Identity\Pages\V4\Account\Manage\DownloadPersonalData.cshtml.cs (1)

78return new FileContentResult(JsonSerializer.SerializeToUtf8Bytes(personalData), "application/json");

Areas\Identity\Pages\V5\Account\Manage\DownloadPersonalData.cshtml.cs (1)

78return new FileContentResult(JsonSerializer.SerializeToUtf8Bytes(personalData), "application/json");

Microsoft.AspNetCore.JsonPatch.SystemTextJson (6)

Helpers\JsonUtilities.cs (1)

44var docA = JsonSerializer.SerializeToDocument(item, serializerOptions);

Internal\ConversionResultProvider.cs (3)

79return JsonSerializer.Deserialize(jsonElement, targetType, serializerOptions); 82using JsonDocument doc = JsonSerializer.SerializeToDocument(value, serializerOptions); 83return JsonSerializer.Deserialize(doc.RootElement, targetType, serializerOptions);

Internal\JsonObjectAdapter.cs (2)

22obj[segment] = value != null ? JsonSerializer.SerializeToNode(value, serializerOptions) : GetJsonNull(); 83obj[index] = value != null ? JsonSerializer.SerializeToNode(value, serializerOptions) : GetJsonNull();

Microsoft.AspNetCore.JsonPatch.SystemTextJson.Tests (19)

IntegrationTests\HeterogenousCollectionTests.cs (4)

96return JsonSerializer.Deserialize<Circle>(root.GetRawText(), options); 100return JsonSerializer.Deserialize<Rectangle>(root.GetRawText(), options); 112JsonSerializer.Serialize(writer, circle, options); 116JsonSerializer.Serialize(writer, rectangle, options);

IntegrationTests\NestedObjectIntegrationTest.cs (2)

50var serialized = JsonSerializer.Serialize(patchDocument); 51var deserialized = JsonSerializer.Deserialize<JsonPatchDocument<SimpleObjectWithNestedObject>>(serialized);

JsonPatchDocumentJObjectTest.cs (2)

18var model = new ObjectWithJObject { CustomData = (JsonObject)JsonSerializer.SerializeToNode(new { Emails = new[] { "foo@bar.com" } }) }; 34var model = new ObjectWithJObject { CustomData = (JsonObject)JsonSerializer.SerializeToNode(new { Email = "foo@bar.com", Name = "Bar" }) };

JsonPatchDocumentTest.cs (11)

65var serialized = JsonSerializer.Serialize(patchDocument); 66var deserialized = JsonSerializer.Deserialize<JsonPatchDocument<SimpleObject>>(serialized); 126var serializedTyped = JsonSerializer.Serialize(patchDocTyped); 127var serializedUntyped = JsonSerializer.Serialize(patchDocUntyped); 128var deserialized = JsonSerializer.Deserialize<JsonPatchDocument>(serializedTyped); 158var serialized = JsonSerializer.Serialize(patchDocument); 161var deserialized = JsonSerializer.Deserialize<JsonPatchDocument<SimpleObject>>(serialized); 177= JsonSerializer.Deserialize<JsonPatchDocument>(serialized); 196= JsonSerializer.Deserialize<JsonPatchDocument<SimpleObject>>(serialized, options); 241var docSuccess = JsonSerializer.Deserialize<JsonPatchDocument<SimpleObject>>(json, compatibleSerializerOption); 256return JsonSerializer.Serialize<JsonPatchDocument<SimpleObject>>(document, jsonSerializerOptions);

Microsoft.AspNetCore.Mvc.Core (15)

Formatters\SystemTextJsonInputFormatter.cs (5)

11/// A <see cref="TextInputFormatter"/> for JSON content that uses <see cref="JsonSerializer"/>. 46/// Gets the <see cref="JsonSerializerOptions"/> used to configure the <see cref="JsonSerializer"/>. 75model = await JsonSerializer.DeserializeAsync(httpContext.Request.Body, context.ModelType, SerializerOptions); 79model = await JsonSerializer.DeserializeAsync(httpContext.Request.BodyReader, context.ModelType, SerializerOptions); 85model = await JsonSerializer.DeserializeAsync(inputStream, context.ModelType, SerializerOptions);

Formatters\SystemTextJsonOutputFormatter.cs (6)

14/// A <see cref="TextOutputFormatter"/> for JSON content that uses <see cref="JsonSerializer"/>. 52/// Gets the <see cref="JsonSerializerOptions"/> used to configure the <see cref="JsonSerializer"/>. 94await JsonSerializer.SerializeAsync(responseWriter, context.Object, jsonTypeInfo, httpContext.RequestAborted); 98await JsonSerializer.SerializeAsync(responseWriter, context.Object, SerializerOptions, httpContext.RequestAborted); 114await JsonSerializer.SerializeAsync(transcodingStream, context.Object, jsonTypeInfo); 118await JsonSerializer.SerializeAsync(transcodingStream, context.Object, SerializerOptions);

FromBodyAttribute.cs (1)

16/// In the case of ASP.NET Core Minimal APIs, the body is deserialized by <see cref="System.Text.Json.JsonSerializer"/>.

Infrastructure\SystemTextJsonResultExecutor.cs (2)

69await JsonSerializer.SerializeAsync(responseWriter, value, objectType, jsonSerializerOptions, context.HttpContext.RequestAborted); 82await JsonSerializer.SerializeAsync(transcodingStream, value, objectType, jsonSerializerOptions, context.HttpContext.RequestAborted);

JsonOptions.cs (1)

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

Microsoft.AspNetCore.Mvc.Core.Test (20)

Formatters\SystemTextJsonOutputFormatterTest.cs (2)

91await JsonSerializer.SerializeAsync(expected, LargeAsync(), JsonSerializerOptions.Web); 287if (JsonSerializer.IsReflectionEnabledByDefault)

Infrastructure\DefaultApiProblemDetailsWriterTest.cs (3)

45var problemDetails = await JsonSerializer.DeserializeAsync<ProblemDetails>(stream, JsonSerializerOptions.Web); 84var problemDetails = await JsonSerializer.DeserializeAsync<ProblemDetails>(stream, JsonSerializerOptions.Web); 115var problemDetails = await JsonSerializer.DeserializeAsync<ProblemDetails>(stream);

Infrastructure\JsonResultExecutorTestBase.cs (10)

26var expected = Encoding.UTF8.GetBytes(JsonSerializer.Serialize(new { foo = "abcd" })); 46var expected = Encoding.UTF8.GetBytes(JsonSerializer.Serialize(new { foo = "abcd" })); 67var expected = Encoding.Unicode.GetBytes(JsonSerializer.Serialize(new { foo = "abcd" })); 91var expected = Encoding.Unicode.GetBytes(JsonSerializer.Serialize(new { foo = "abcd" })); 111var expected = Encoding.UTF8.GetBytes(JsonSerializer.Serialize(new { foo = "abcd" })); 135var expected = Encoding.UTF8.GetBytes(JsonSerializer.Serialize(new { foo = "abcd" })); 161var expected = Encoding.UTF8.GetBytes(JsonSerializer.Serialize(new { foo = "abcd" })); 182var expected = Encoding.UTF8.GetBytes(JsonSerializer.Serialize( 331var expected = JsonSerializer.Serialize(new[] { "Hello", "world" }); 349var expected = Encoding.UTF8.GetBytes(JsonSerializer.Serialize(new[] { 1, 2 }));

Infrastructure\ValidationProblemDetailsJsonConverterTest.cs (5)

30var problemDetails = JsonSerializer.Deserialize<ValidationProblemDetails>(ref reader, JsonSerializerOptions); 72var problemDetails = JsonSerializer.Deserialize<ValidationProblemDetails>(ref reader, JsonSerializerOptions); 110var problemDetails = JsonSerializer.Deserialize<ValidationProblemDetails>(json, JsonSerializerOptions); 149JsonSerializer.Serialize(writer, problemDetails, JsonSerializerOptions); 182JsonSerializer.Serialize(writer, problemDetails, options);

Microsoft.AspNetCore.Mvc.FunctionalTests (8)

AsyncEnumerableTestBase.cs (1)

50var projects = JsonSerializer.Deserialize<List<Project>>(content, TestJsonSerializerOptionsProvider.Options);

BasicTests.cs (7)

437var result = JsonSerializer.Deserialize<Product>(response, TestJsonSerializerOptionsProvider.Options); 451var result = JsonSerializer.Deserialize<Product[]>(response, TestJsonSerializerOptionsProvider.Options); 470var assemblyParts = JsonSerializer.Deserialize<IList<string>>(response, TestJsonSerializerOptionsProvider.Options); 541var data = JsonSerializer.Deserialize<BindPropertyControllerData>(content, TestJsonSerializerOptionsProvider.Options); 564var data = JsonSerializer.Deserialize<BindPropertyControllerData>(content, TestJsonSerializerOptionsProvider.Options); 586var data = JsonSerializer.Deserialize<BindPropertyControllerData>(content, TestJsonSerializerOptionsProvider.Options); 656var problemDetails = JsonSerializer.Deserialize<ValidationProblemDetails>(content, TestJsonSerializerOptionsProvider.Options);

Microsoft.AspNetCore.Mvc.NewtonsoftJson.Test (11)

NewtonsoftJsonResultExecutorTest.cs (1)

35var expected = System.Text.Json.JsonSerializer.Serialize(new[] { "Hello", "world" });

src\Mvc\Mvc.Core\test\Infrastructure\JsonResultExecutorTestBase.cs (10)

Microsoft.AspNetCore.Mvc.TagHelpers.Test (2)

ProtectedPrerenderComponentApplicationStateTest.cs (2)

45var persistedState = Convert.ToBase64String(_protector.Protect(JsonSerializer.SerializeToUtf8Bytes(expectedState))); 66var persistedState = Convert.ToBase64String(JsonSerializer.SerializeToUtf8Bytes(expectedState));

Microsoft.AspNetCore.Mvc.Testing (1)

WebApplicationFactory.cs (1)

391var data = JsonSerializer.Deserialize(File.ReadAllBytes(file), CustomJsonSerializerContext.Default.IDictionaryStringString)!;

Microsoft.AspNetCore.Mvc.ViewFeatures (1)

Rendering\SystemTextJsonHelper.cs (1)

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

Microsoft.AspNetCore.OpenApi (4)

Extensions\JsonNodeSchemaExtensions.cs (1)

184schema[OpenApiSchemaKeywords.DefaultKeyword] = JsonSerializer.SerializeToNode(defaultValue, jsonTypeInfo);

Schemas\OpenApiJsonSchema.Helpers.cs (2)

35values.Add((T)JsonSerializer.Deserialize(ref reader, typeof(T), OpenApiJsonSchemaContext.Default)!); 80values[key] = (T)JsonSerializer.Deserialize(ref reader, typeof(T), OpenApiJsonSchemaContext.Default)!;

Services\Schemas\OpenApiSchemaService.cs (1)

242var deserializedSchema = JsonSerializer.Deserialize(schemaAsJsonObject, _jsonSchemaContext.OpenApiJsonSchema);

Microsoft.AspNetCore.OpenApi.Build.Tests (1)

GenerateAdditionalXmlFilesForOpenApiTests.cs (1)

33var result = JsonSerializer.Deserialize<ItemsResult>(output);

Microsoft.AspNetCore.Routing.FunctionalTests (5)

MinimalFormTests.cs (5)

67var result = JsonSerializer.Deserialize<Todo>(body, JsonSerializerOptions.Web); 127var result = JsonSerializer.Deserialize<Todo>(body, JsonSerializerOptions.Web); 288var result = JsonSerializer.Deserialize<Todo>(body, JsonSerializerOptions.Web); 335var result = JsonSerializer.Deserialize<Todo>(body, JsonSerializerOptions.Web); 495var result = JsonSerializer.Deserialize<Todo>(body, JsonSerializerOptions.Web);

Microsoft.AspNetCore.SignalR.Protocols.Json (2)

Protocol\JsonHubProtocol.cs (2)

917private void SerializeObject(Utf8JsonWriter writer, object? value) => JsonSerializer.Serialize(writer, value, _payloadSerializerOptions); 921private object? DeserializeObject(ref Utf8JsonReader reader, Type type) => JsonSerializer.Deserialize(ref reader, type, _payloadSerializerOptions);

Microsoft.AspNetCore.StaticAssets (1)

StaticAssetsManifest.cs (1)

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

Microsoft.AspNetCore.StaticAssets.Tests (1)

StaticAssetsIntegrationTests.cs (1)

539JsonSerializer.Serialize(writer, manifest);

Microsoft.AspNetCore.Watch.BrowserRefresh (2)

BlazorWasmHotReloadMiddleware.cs (2)

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

Microsoft.AspNetCore.Watch.BrowserRefresh.Tests (2)

BlazorWasmHotReloadMiddlewareTest.cs (2)

231JsonSerializer.SerializeToUtf8Bytes(updates, new JsonSerializerOptions(JsonSerializerDefaults.Web)), 259var bytes = JsonSerializer.SerializeToUtf8Bytes(obj, new JsonSerializerOptions(JsonSerializerDefaults.Web));

Microsoft.Build (4)

TelemetryInfra\TelemetryDataUtils.cs (4)

32JsonSerializer.Serialize(telemetryData.TasksExecutionData, _serializerOptions), false)); 38JsonSerializer.Serialize(telemetryData.TargetsExecutionData, _serializerOptions), false)); 44JsonSerializer.Serialize(targetsSummary, _serializerOptions), false)); 49JsonSerializer.Serialize(tasksSummary, _serializerOptions), false));

Microsoft.CodeAnalysis.CSharp.EditorFeatures (2)

StringCopyPaste\StringCopyPasteData.cs (2)

32return JsonSerializer.Serialize(this, typeof(StringCopyPasteData)); 48var value = JsonSerializer.Deserialize(JsonDocument.Parse(json), typeof(StringCopyPasteData));

Microsoft.CodeAnalysis.CSharp.EditorFeatures.UnitTests (1)

Rename\CSharpInlineRenameServiceTests.cs (1)

73var expectedContext = JsonSerializer.Deserialize<ImmutableDictionary<string, ImmutableArray<(string, string)>>>(expectedContextJson, serializationOptions);

Microsoft.CodeAnalysis.ExternalAccess.Razor.Features (4)

Cohost\RazorSemanticTokensRefreshQueueWrapper.cs (1)

34var clientCapabilities = JsonSerializer.Deserialize<VSInternalClientCapabilities>(clientCapabilitiesString) ?? new();

Cohost\RazorStartupServiceFactory.cs (1)

92var serializedClientCapabilities = JsonSerializer.Serialize(clientCapabilities, ProtocolConversions.LspJsonSerializerOptions);

Testing\RazorTestLanguageServerFactory.cs (2)

90var clientCapabilitiesJson = JsonSerializer.Serialize(clientCapabilities, _options); 92var serverCapabilities = JsonSerializer.Deserialize<VSInternalServerCapabilities>(serverCapabilitiesJson, _options);

Microsoft.CodeAnalysis.ExternalAccess.Xaml (2)

External\ResolveDataConversions.cs (2)

24var resolveData = JsonSerializer.Deserialize<DataResolveData>((JsonElement)requestData); 40resolveData = JsonSerializer.Deserialize<DataIdResolveData>(token);

Microsoft.CodeAnalysis.Features (3)

Extensions\ExtensionMessageHandlerService.cs (2)

238var message = JsonSerializer.Deserialize(jsonMessage, handler.MessageType); 240return new(JsonSerializer.Serialize(result, handler.ResponseType), ExtensionWasUnloaded: false, ExtensionException: null);

Intents\IntentDataProvider.cs (1)

33return JsonSerializer.Deserialize<T>(_serializedIntentData, s_serializerOptions.Value);

Microsoft.CodeAnalysis.LanguageServer (3)

FileBasedPrograms\VirtualProjectXmlProvider.cs (2)

92var inputJson = JsonSerializer.Serialize(input, RunFileApiJsonSerializerContext.Default.RunApiInput); 118var response = JsonSerializer.Deserialize(responseJson, RunFileApiJsonSerializerContext.Default.RunApiOutput);

Program.cs (1)

150Console.WriteLine(JsonSerializer.Serialize(new NamedPipeInformation(clientPipeName)));

Microsoft.CodeAnalysis.LanguageServer.Protocol (43)

Handler\CodeActions\CodeActionFixAllResolveHandler.cs (1)

69var resolveData = JsonSerializer.Deserialize<CodeActionResolveData>((JsonElement)request.Data!, ProtocolConversions.LspJsonSerializerOptions);

Handler\CodeActions\CodeActionResolveHandler.cs (1)

100var resolveData = JsonSerializer.Deserialize<CodeActionResolveData>((JsonElement)request.Data!, ProtocolConversions.LspJsonSerializerOptions);

Handler\CodeLens\CodeLensResolveHandler.cs (1)

95var resolveData = JsonSerializer.Deserialize<CodeLensResolveData>((JsonElement)codeLens.Data, ProtocolConversions.LspJsonSerializerOptions);

Handler\Completion\CompletionResolveHandler.cs (1)

128var resolveData = JsonSerializer.Deserialize<DocumentResolveData>((JsonElement)request.Data);

Handler\Completion\Extensions.cs (1)

54var resolveData = JsonSerializer.Deserialize<CompletionResolveData>((JsonElement)request.Data, ProtocolConversions.LspJsonSerializerOptions);

Handler\InlayHint\InlayHintResolveHandler.cs (1)

85var resolveData = JsonSerializer.Deserialize<InlayHintResolveData>((JsonElement)inlayHint.Data, ProtocolConversions.LspJsonSerializerOptions);

Handler\ServerLifetime\InitializeHandler.cs (1)

44m["capabilities"] = JsonSerializer.Serialize(serverCapabilities, ProtocolConversions.LspJsonSerializerOptions);

Protocol\Converters\FormattingOptionsConverter.cs (1)

141JsonSerializer.Serialize(writer, item.Value, options);

Protocol\Converters\InitializeParamsWorkspaceFoldersConverter.cs (2)

31return JsonSerializer.Deserialize<WorkspaceFolder[]>(ref reader, options) ?? []; 36JsonSerializer.Serialize(writer, value, options);

Protocol\Converters\NaturalObjectConverter.cs (2)

28JsonSerializer.Serialize(writer, value, runtimeType, options); 67return JsonSerializer.Deserialize<JsonElement>(ref reader);

Protocol\Converters\ParameterInformationConverter.cs (2)

47JsonSerializer.Serialize(writer, value.Label, options); 52JsonSerializer.Serialize(writer, value.Documentation, options);

Protocol\Converters\SumConverter.cs (2)

142private static readonly MethodInfo jsonSerializerDeserializeMethod = typeof(JsonSerializer) 279JsonSerializer.Serialize(writer, sumValue, options);

Protocol\Converters\TextDocumentSyncConverter.cs (3)

35return JsonSerializer.Deserialize<TextDocumentSyncOptions>(value); 39return JsonSerializer.Deserialize<TextDocumentSyncOptions>(ref reader, options); 48JsonSerializer.Serialize(writer, value, options);

Protocol\Extensions\Converters\VSExtensionConverter.cs (3)

25return JsonSerializer.Deserialize<TExtension>(ref reader, options); 34JsonSerializer.Serialize(writer, extension, options); 40JsonSerializer.Serialize(writer, (object)value!, DropConverter(options));

Protocol\Internal\Converters\ObjectContentConverter.cs (1)

78return JsonSerializer.Deserialize(ref reader, objectType, options);

Protocol\Internal\Efficiency\OptimizedVSCompletionListJsonConverter.cs (16)

RoslynLanguageServer.cs (2)

196var textDocumentIdentifier = JsonSerializer.Deserialize<TextDocumentIdentifier>(textDocumentToken, ProtocolConversions.LspJsonSerializerOptions); 207var data = JsonSerializer.Deserialize<DocumentResolveData>(dataToken, ProtocolConversions.LspJsonSerializerOptions);

src\LanguageServer\Microsoft.CommonLanguageServerProtocol.Framework\SystemTextJsonLanguageServer.cs (2)

49return JsonSerializer.Deserialize<TRequest>(request, _jsonSerializerOptions) 93var serializedResult = JsonSerializer.SerializeToElement(result, target._jsonSerializerOptions);

Microsoft.CodeAnalysis.LanguageServer.Protocol.UnitTests (11)

CodeActions\CodeActionsTests.cs (3)

94r => JsonSerializer.Deserialize<CodeActionResolveData>((JsonElement)r.Data!, ProtocolConversions.LspJsonSerializerOptions)!.UniqueIdentifier == titlePath[1]); 288return JsonSerializer.Deserialize<CodeActionResolveData>((JsonElement)codeAction.Data!, ProtocolConversions.LspJsonSerializerOptions); 313Data = JsonSerializer.SerializeToElement(data, ProtocolConversions.LspJsonSerializerOptions),

CodeActions\RunCodeActionsTests.cs (1)

70JsonSerializer.SerializeToElement(codeActionData, ProtocolConversions.LspJsonSerializerOptions)

CodeLens\CSharpCodeLensTests.cs (1)

438var data = JsonSerializer.Deserialize<CodeLensResolveData>(firstCodeLens.Data!.ToString()!, ProtocolConversions.LspJsonSerializerOptions);

Commands\ExecuteWorkspaceCommandTests.cs (2)

38Arguments = [JsonSerializer.Serialize(new TextDocumentIdentifier { DocumentUri = ProtocolConversions.CreateAbsoluteDocumentUri(@"C:\someFile.cs") })], 67return JsonSerializer.Deserialize<TextDocumentIdentifier>((JsonElement)request.Arguments!.First(), ProtocolConversions.LspJsonSerializerOptions)!;

Diagnostics\DiagnosticRegistrationTests.cs (1)

59.Select(r => JsonSerializer.Deserialize<DiagnosticRegistrationOptions>((JsonElement)r.RegisterOptions!, ProtocolConversions.LspJsonSerializerOptions)!);

InlayHint\CSharpInlayHintTests.cs (1)

126var data = JsonSerializer.Deserialize<InlayHintResolveData>(firstInlayHint.Data!.ToString()!, ProtocolConversions.LspJsonSerializerOptions);

References\FindAllReferencesHandlerTests.cs (1)

438.SelectMany(r => (List<object>)r).Select(r => JsonSerializer.Deserialize<T>((JsonElement)r, ProtocolConversions.LspJsonSerializerOptions))];

UriTests.cs (1)

182var unencodedUri = JsonSerializer.Deserialize<LSP.DidOpenTextDocumentParams>(jsonDocument, JsonSerializerOptions)!.TextDocument.DocumentUri;

Microsoft.CodeAnalysis.LanguageServer.UnitTests (1)

LspFileChangeWatcherTests.cs (1)

111var registration = JsonSerializer.Deserialize<DidChangeWatchedFilesRegistrationOptions>(registrationJson, ProtocolConversions.LspJsonSerializerOptions)!;

Microsoft.CodeAnalysis.Workspaces.UnitTests (1)

UtilityTest\ExceptionHelpersTests.cs (1)

66Assert.NotNull(JsonSerializer.Serialize(e));

Microsoft.CommonLanguageServerProtocol.Framework.Package (2)

SystemTextJsonLanguageServer.cs (2)

49return JsonSerializer.Deserialize<TRequest>(request, _jsonSerializerOptions) 93var serializedResult = JsonSerializer.SerializeToElement(result, target._jsonSerializerOptions);

Microsoft.DotNet.Build.Tasks.Feed (2)

src\ProductionChannelValidator.cs (2)

402var buildResponse = JsonSerializer.Deserialize<AzureDevOpsBuildInfoResponse>(content, new JsonSerializerOptions 463var classification = JsonSerializer.Deserialize<BranchClassificationResponse>(content, new JsonSerializerOptions

Microsoft.DotNet.Build.Tasks.Workloads (2)

Msi\MsiProperties.wix.cs (1)

116File.WriteAllText(msiJsonPath, JsonSerializer.Serialize(properties));

Msi\WorkloadManifestMsi.wix.cs (1)

79string jsonAsString = JsonSerializer.Serialize(WorkloadPackGroups, typeof(IList<WorkloadPackGroupJson>), new JsonSerializerOptions() { WriteIndented = true });

Microsoft.DotNet.HotReload.Client.Package (3)

Web\AbstractBrowserRefreshServer.cs (3)

Microsoft.DotNet.HotReload.Client.Tests (3)

AbstractBrowserRefreshServer.cs (3)

Microsoft.DotNet.HotReload.WebAssembly.Browser (3)

WebAssemblyHotReload.cs (3)

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

Microsoft.DotNet.Internal.SymbolHelper (1)

SymbolPromotionHelper.cs (1)

218return await JsonSerializer.DeserializeAsync<SymbolRequestStatus>(result, s_options, cancellationToken: ct);

Microsoft.DotNet.MSBuildSdkResolver (4)

InstallStateContents.cs (2)

35return JsonSerializer.Deserialize<InstallStateContents>(contents, s_options) ?? new InstallStateContents(); 45return JsonSerializer.Serialize(this, s_options);

WorkloadSet.cs (2)

73return FromDictionaryForJson(JsonSerializer.Deserialize<IDictionary<string, string>>(json, jsonSerializerOptions)!, defaultFeatureBand); 123var json = JsonSerializer.Serialize(ToDictionaryForJson(), new JsonSerializerOptions() { WriteIndented = true });

Microsoft.DotNet.TemplateLocator (4)

InstallStateContents.cs (2)

35return JsonSerializer.Deserialize<InstallStateContents>(contents, s_options) ?? new InstallStateContents(); 45return JsonSerializer.Serialize(this, s_options);

WorkloadSet.cs (2)

Microsoft.DotNet.Tools.Tests.ComponentMocks (2)

AppHostShellShimMakerMock.cs (1)

31JsonSerializer.Serialize(shim));

ToolPackageDownloaderMock.cs (1)

151JsonSerializer.Serialize(new { Name = feedPackage.ToolCommandName }));

Microsoft.DotNet.XliffTasks (2)

Model\JsonDocument.cs (2)

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

Microsoft.Extensions.AI (15)

ChatCompletion\ChatClientStructuredOutputExtensions.cs (1)

162schema = JsonSerializer.SerializeToElement(new JsonObject

ChatCompletion\ChatResponse{T}.cs (1)

104return 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)

308element = JsonSerializer.SerializeToElement(content, unknownContentTypeInfo); 328return JsonSerializer.Serialize(output, _defaultOptions.GetTypeInfo(typeof(IList<object>))); 423JsonSerializer.Serialize(options.Tools.Select(t => t switch 576JsonSerializer.Serialize(new object[1] { new OtelGenericPart { Content = options!.Instructions } }, _defaultOptions.GetTypeInfo(typeof(IList<object>)))); 632private static readonly JsonElement _emptyObject = JsonSerializer.SerializeToElement(new object(), _defaultOptions.GetTypeInfo(typeof(object)));

Embeddings\DistributedCachingEmbeddingGenerator.cs (2)

83return JsonSerializer.Deserialize(existingJson, (JsonTypeInfo<TEmbedding>)_jsonSerializerOptions.GetTypeInfo(typeof(TEmbedding))); 96var newJson = JsonSerializer.SerializeToUtf8Bytes(value, (JsonTypeInfo<TEmbedding>)_jsonSerializerOptions.GetTypeInfo(typeof(TEmbedding)));

Embeddings\LoggingEmbeddingGenerator.cs (1)

90private string AsJson<T>(T value) => JsonSerializer.Serialize(value, _jsonSerializerOptions.GetTypeInfo(typeof(T)));

TelemetryHelpers.cs (1)

26return JsonSerializer.Serialize(value, typeInfo);

Microsoft.Extensions.AI.Abstractions (22)

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)

871JsonElement element => JsonSerializer.Deserialize(element, typeInfo), 872JsonDocument doc => JsonSerializer.Deserialize(doc, typeInfo), 873JsonNode node => JsonSerializer.Deserialize(node, typeInfo), 890return JsonSerializer.Deserialize(text, typeInfo); 898string json = JsonSerializer.Serialize(value, serializerOptions.GetTypeInfo(value.GetType())); 899return JsonSerializer.Deserialize(json, typeInfo); 1092return JsonSerializer.SerializeToElement(result, returnTypeInfo); 1097await JsonSerializer.SerializeAsync(stream, result, returnTypeInfo, cancellationToken).ConfigureAwait(true);

src\Shared\JsonSchemaExporter\JsonSchemaExporter.cs (1)

721defaultValue = JsonSerializer.SerializeToNode(defaultVal, parameterTypeInfo);

Utilities\AIJsonUtilities.cs (2)

134JsonNode? jsonNode = JsonSerializer.SerializeToNode(value, jti); 136JsonSerializer.Serialize(stream, jsonNode, JsonContextNoIndentation.Default.JsonNode!);

Utilities\AIJsonUtilities.Defaults.cs (2)

22/// <para>For Native AOT or applications disabling <see cref="JsonSerializer.IsReflectionEnabledByDefault"/> this instance includes source generated contracts 61if (JsonSerializer.IsReflectionEnabledByDefault)

Utilities\AIJsonUtilities.Schema.Create.cs (4)

157return JsonSerializer.SerializeToElement(schema, JsonContextNoIndentation.Default.JsonNode); 186return JsonSerializer.SerializeToElement(schema, JsonContextNoIndentation.Default.JsonNode); 232? JsonSerializer.SerializeToNode(defaultValue, serializerOptions.GetTypeInfo(defaultValue.GetType())) 343JsonNode? defaultValueNode = JsonSerializer.SerializeToNode(defaultValue, ctx.TypeInfo);

Utilities\AIJsonUtilities.Schema.Transform.cs (3)

32JsonNode? nodeSchema = JsonSerializer.SerializeToNode(schema, JsonContext.Default.JsonElement); 34return JsonSerializer.SerializeToElement(transformedSchema, JsonContextNoIndentation.Default.JsonNode); 181string defaultValueJson = JsonSerializer.Serialize(defaultSchema, JsonContextNoIndentation.Default.JsonNode!);

Microsoft.Extensions.AI.Abstractions.Tests (122)

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)

186string json = JsonSerializer.Serialize(options, TestJsonSerializerContext.Default.ChatOptions); 188ChatOptions? deserialized = JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.ChatOptions);

ChatCompletion\ChatResponseFormatTests.cs (10)

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( 79ChatResponseFormat.ForJsonSchema(JsonSerializer.Deserialize<JsonElement>("[1,2,3]", AIJsonUtilities.DefaultOptions), "name", "description"), 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);

Contents\AIAnnotationTests.cs (3)

52string json = JsonSerializer.Serialize(original, AIJsonUtilities.DefaultOptions.GetTypeInfo(typeof(AIAnnotation))); 55var deserialized = (AIAnnotation?)JsonSerializer.Deserialize(json, AIJsonUtilities.DefaultOptions.GetTypeInfo(typeof(AIAnnotation))); 60Assert.Equal(JsonSerializer.Deserialize<JsonElement>("\"value\"", AIJsonUtilities.DefaultOptions).ToString(), deserialized.AdditionalProperties["key"]!.ToString());

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))); 81var serialized = JsonSerializer.Serialize(message, AIJsonUtilities.DefaultOptions); 82ChatMessage? deserialized = JsonSerializer.Deserialize<ChatMessage>(serialized, AIJsonUtilities.DefaultOptions);

Contents\CitationAnnotationTests.cs (3)

78string json = JsonSerializer.Serialize(original, AIJsonUtilities.DefaultOptions.GetTypeInfo(typeof(CitationAnnotation))); 81var deserialized = (CitationAnnotation?)JsonSerializer.Deserialize(json, AIJsonUtilities.DefaultOptions.GetTypeInfo(typeof(CitationAnnotation))); 86Assert.Equal(JsonSerializer.Deserialize<JsonElement>("\"value\"", AIJsonUtilities.DefaultOptions).ToString(), deserialized.AdditionalProperties["key"]!.ToString());

Contents\DataContentTests.cs (9)

114JsonSerializer.Serialize( 120JsonSerializer.Serialize( 126JsonSerializer.Serialize( 136Assert.Throws<ArgumentNullException>("uri", () => JsonSerializer.Deserialize<DataContent>(json, TestJsonSerializerContext.Default.Options)!); 143var content = JsonSerializer.Deserialize<DataContent>("""{"uri":"data:application/octet-stream;base64,AQIDBA=="}""", TestJsonSerializerContext.Default.Options)!; 151content = JsonSerializer.Deserialize<DataContent>("""{"uri":"data:application/octet-stream;base64,AQIDBA=="}""", TestJsonSerializerContext.Default.Options)!; 157content = JsonSerializer.Deserialize<DataContent>(""" 184var content = JsonSerializer.Deserialize<DataContent>(serialized, TestJsonSerializerContext.Default.Options)!; 185var 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\FunctionCallContentTests.cs (9)

84var json = JsonSerializer.SerializeToNode(sut, TestJsonSerializerContext.Default.Options); 85var deserializedSut = JsonSerializer.Deserialize<FunctionCallContent>(json, TestJsonSerializerContext.Default.Options); 119AIFunctionArguments arguments = JsonSerializer.Deserialize<AIFunctionArguments>(""" 153var arguments = JsonSerializer.Deserialize<Dictionary<string, JsonDocument>>(""" 174var arguments = JsonSerializer.Deserialize<Dictionary<string, JsonNode>>(""" 195AIFunctionArguments arguments = new(JsonSerializer.Deserialize<Dictionary<string, JsonDocument>>(""" 213AIFunctionArguments arguments = new(JsonSerializer.Deserialize<Dictionary<string, object?>>(""" 231AIFunctionArguments arguments = new(JsonSerializer.Deserialize<Dictionary<string, JsonNode>>(""" 265argumentParser: static json => JsonSerializer.Deserialize<Dictionary<string, object?>>(json, AIJsonUtilities.DefaultOptions));

Contents\FunctionResultContentTests.cs (4)

68var json = JsonSerializer.Serialize(sut, TestJsonSerializerContext.Default.Options); 70var deserializedSut = JsonSerializer.Deserialize<FunctionResultContent>(json, TestJsonSerializerContext.Default.Options); 85var json = JsonSerializer.Serialize(sut, TestJsonSerializerContext.Default.Options); 86var deserializedSut = JsonSerializer.Deserialize<FunctionResultContent>(json, TestJsonSerializerContext.Default.Options);

Contents\UriContentTests.cs (1)

69JsonSerializer.Serialize(

Embeddings\BinaryEmbeddingTests.cs (4)

68string json = JsonSerializer.Serialize(e, TestJsonSerializerContext.Default.Embedding); 71BinaryEmbedding result = Assert.IsType<BinaryEmbedding>(JsonSerializer.Deserialize(json, TestJsonSerializerContext.Default.Embedding)); 79BinaryEmbedding result = Assert.IsType<BinaryEmbedding>(JsonSerializer.Deserialize( 93Assert.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)

99string json = JsonSerializer.Serialize(original, TestJsonSerializerContext.Default.SpeechToTextResponseUpdate); 100SpeechToTextResponseUpdate? 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!);

Utilities\AIJsonUtilitiesTests.cs (10)

57string json = JsonSerializer.Serialize(input, options); 69Assert.Equal(!isDotnetCore, JsonSerializer.IsReflectionEnabledByDefault); 70Assert.Equal(JsonSerializer.IsReflectionEnabledByDefault, AIJsonUtilities.DefaultOptions.TryGetTypeInfo(anonType, out _)); 449JsonNode? schemaAsNode = JsonSerializer.SerializeToNode(schema, options); 462JsonNode? serializedValue = JsonSerializer.SerializeToNode(testData.Value, testData.Type, options); 502AssertDeepEquals(JsonSerializer.Deserialize( 738AssertDeepEquals(JsonSerializer.Deserialize( 1014string json = JsonSerializer.Serialize(c, options); 1017AIContent? deserialized = JsonSerializer.Deserialize<AIContent>(json, options); 1052Assert.Throws<InvalidOperationException>(() => JsonSerializer.Serialize(c, options));

Microsoft.Extensions.AI.AzureAIInference (12)

AzureAIInferenceChatClient.cs (10)

322result.AdditionalProperties["top_k"] = new BinaryData(JsonSerializer.SerializeToUtf8Bytes(topK, AIJsonUtilities.DefaultOptions.GetTypeInfo(typeof(int)))); 329byte[] data = JsonSerializer.SerializeToUtf8Bytes(prop.Value, AIJsonUtilities.DefaultOptions.GetTypeInfo(typeof(object))); 376var tool = JsonSerializer.Deserialize(schema, JsonContext.Default.AzureAIChatToolJson)!; 382["properties"] = BinaryData.FromBytes(JsonSerializer.SerializeToUtf8Bytes(tool.Properties, JsonContext.Default.DictionaryStringJsonElement)), 383["required"] = BinaryData.FromBytes(JsonSerializer.SerializeToUtf8Bytes(tool.Required, JsonContext.Default.ListString)), 408var tool = JsonSerializer.Deserialize(SchemaTransformCache.GetOrCreateTransformedSchema(aiFunction), JsonContext.Default.AzureAIChatToolJson)!; 409var functionParameters = BinaryData.FromBytes(JsonSerializer.SerializeToUtf8Bytes(tool, JsonContext.Default.AzureAIChatToolJson)); 449result = JsonSerializer.Serialize(resultContent.Result, AIJsonUtilities.DefaultOptions.GetTypeInfo(typeof(object))); 490JsonSerializer.Serialize(callRequest.Arguments, AIJsonUtilities.DefaultOptions.GetTypeInfo(typeof(IDictionary<string, object>)))))); 550argumentParser: static json => JsonSerializer.Deserialize(json,

AzureAIInferenceEmbeddingGenerator.cs (1)

189byte[] data = JsonSerializer.SerializeToUtf8Bytes(prop.Value, AIJsonUtilities.DefaultOptions.GetTypeInfo(typeof(object)));

AzureAIInferenceImageEmbeddingGenerator.cs (1)

143byte[] data = JsonSerializer.SerializeToUtf8Bytes(prop.Value, AIJsonUtilities.DefaultOptions.GetTypeInfo(typeof(object)));

Microsoft.Extensions.AI.AzureAIInference.Tests (11)

AzureAIInferenceChatClientTests.cs (8)

623var tool = JsonSerializer.Deserialize<AzureAIChatToolJson>(aiFunction.JsonSchema)!; 624var functionParameters = BinaryData.FromBytes(JsonSerializer.SerializeToUtf8Bytes(tool)); 697azureAIOptions.AdditionalProperties.Add("something_else", new BinaryData(JsonSerializer.SerializeToUtf8Bytes("value1", typeof(object)))); 698azureAIOptions.AdditionalProperties.Add("and_something_further", new BinaryData(JsonSerializer.SerializeToUtf8Bytes(123, typeof(object)))); 756azureAIOptions.AdditionalProperties.Add("top_k", new BinaryData(JsonSerializer.SerializeToUtf8Bytes(40, typeof(object)))); 757azureAIOptions.AdditionalProperties.Add("something_else", new BinaryData(JsonSerializer.SerializeToUtf8Bytes("value1", typeof(object)))); 758azureAIOptions.AdditionalProperties.Add("and_something_further", new BinaryData(JsonSerializer.SerializeToUtf8Bytes(123, typeof(object)))); 889ResponseFormat = ChatResponseFormat.ForJsonSchema(JsonSerializer.Deserialize<JsonElement>("""

test\Libraries\Microsoft.Extensions.AI.Abstractions.Tests\AssertExtensions.cs (3)

Microsoft.Extensions.AI.Evaluation.Quality (4)

ChatMessageExtensions.cs (1)

22JsonSerializer.SerializeToNode(

ChatResponseExtensions.cs (1)

37JsonSerializer.SerializeToNode(

IntentResolutionRating.cs (1)

79return JsonSerializer.Deserialize(trimmed, SerializerContext.Default.IntentResolutionRating)!;

RelevanceTruthAndCompletenessRating.cs (1)

78return JsonSerializer.Deserialize(trimmed, SerializerContext.Default.RelevanceTruthAndCompletenessRating)!;

Microsoft.Extensions.AI.Evaluation.Reporting (10)

Formats\Html\HtmlReportWriter.cs (1)

56await JsonSerializer.SerializeAsync(

Formats\Json\JsonReportWriter.cs (1)

45await JsonSerializer.SerializeAsync(

JsonSerialization\EvaluationContextConverter.cs (2)

69contents = JsonSerializer.Deserialize(ref reader, contentsTypeInfo) as IReadOnlyList<AIContent>; 91JsonSerializer.Serialize(writer, value.Contents, contentsTypeInfo);

Storage\DiskBasedResponseCache.CacheEntry.cs (4)

36JsonSerializer.Deserialize( 52await JsonSerializer.DeserializeAsync( 65JsonSerializer.Serialize(cacheEntryFile, this, JsonUtilities.Default.CacheEntryTypeInfo); 73await JsonSerializer.SerializeAsync(

Storage\DiskBasedResultStore.cs (2)

69await JsonSerializer.DeserializeAsync( 101await JsonSerializer.SerializeAsync(

Microsoft.Extensions.AI.Evaluation.Reporting.Azure (8)

src\Libraries\Microsoft.Extensions.AI.Evaluation.Reporting\CSharp\JsonSerialization\EvaluationContextConverter.cs (2)

69contents = JsonSerializer.Deserialize(ref reader, contentsTypeInfo) as IReadOnlyList<AIContent>; 91JsonSerializer.Serialize(writer, value.Contents, contentsTypeInfo);

Storage\AzureStorageResponseCache.CacheEntry.cs (4)

41JsonSerializer.Deserialize( 58await JsonSerializer.DeserializeAsync( 74JsonSerializer.Serialize(stream, this, AzureStorageJsonUtilities.Default.CacheEntryTypeInfo); 86await JsonSerializer.SerializeAsync(

Storage\AzureStorageResultStore.cs (2)

115ScenarioRunResult? result = await JsonSerializer.DeserializeAsync( 166await JsonSerializer.SerializeAsync(

Microsoft.Extensions.AI.Evaluation.Reporting.Tests (36)

CacheEntryTests.cs (4)

26string json = JsonSerializer.Serialize(entry, JsonUtilities.Default.CacheEntryTypeInfo); 27CacheEntry? deserialized = JsonSerializer.Deserialize(json, JsonUtilities.Default.CacheEntryTypeInfo); 46string json = JsonSerializer.Serialize(entry, JsonUtilities.Compact.CacheEntryTypeInfo); 47CacheEntry? deserialized = JsonSerializer.Deserialize(json, JsonUtilities.Default.CacheEntryTypeInfo);

ChatTurnDetailsTests.cs (18)

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)

63string text = JsonSerializer.Serialize(_scenarioRunResult, JsonUtilities.Default.ScenarioRunResultTypeInfo); 64ScenarioRunResult? response = JsonSerializer.Deserialize(text, JsonUtilities.Default.ScenarioRunResultTypeInfo); 72string text = JsonSerializer.Serialize(_scenarioRunResult, JsonUtilities.Compact.ScenarioRunResultTypeInfo); 73ScenarioRunResult? response = JsonSerializer.Deserialize(text, JsonUtilities.Compact.ScenarioRunResultTypeInfo); 81string text = JsonSerializer.Serialize(_scenarioRunResult, AzureStorageJsonUtilities.Default.ScenarioRunResultTypeInfo); 82ScenarioRunResult? response = JsonSerializer.Deserialize(text, AzureStorageJsonUtilities.Default.ScenarioRunResultTypeInfo); 90string text = JsonSerializer.Serialize(_scenarioRunResult, AzureStorageJsonUtilities.Compact.ScenarioRunResultTypeInfo); 91ScenarioRunResult? response = JsonSerializer.Deserialize(text, AzureStorageJsonUtilities.Compact.ScenarioRunResultTypeInfo);

Microsoft.Extensions.AI.Evaluation.Tests (4)

IntentResolutionRatingTests.cs (2)

118string json = JsonSerializer.Serialize(rating, SerializerContext.Default.IntentResolutionRating); 136string json = JsonSerializer.Serialize(rating, SerializerContext.Default.IntentResolutionRating);

RelevanceTruthAndCompletenessRatingTests.cs (2)

142string json = JsonSerializer.Serialize(rating, SerializerContext.Default.RelevanceTruthAndCompletenessRating); 162string json = JsonSerializer.Serialize(rating, SerializerContext.Default.RelevanceTruthAndCompletenessRating);

Microsoft.Extensions.AI.Integration.Tests (10)

ChatClientIntegrationTests.cs (1)

521public override JsonElement JsonSchema { get; } = JsonSerializer.Deserialize<JsonElement>(jsonSchema, AIJsonUtilities.DefaultOptions);

PromptBasedFunctionCallingChatClient.cs (4)

71var toolCallResultJson = JsonSerializer.Serialize(new ToolCallResult { Id = frc.CallId, Result = frc.Result }, _jsonOptions); 76var toolCallJson = JsonSerializer.Serialize(new { fcc.CallId, fcc.Name, fcc.Arguments }, _jsonOptions); 109var toolCallParsed = JsonSerializer.Deserialize<ToolCall>(ref reader, _jsonOptions); 169var toolDescriptorsJson = JsonSerializer.Serialize(tools.OfType<AIFunction>().Select(t => t.JsonSchema), _jsonOptions);

VerbatimMultiPartHttpHandler.cs (5)

138var jsonParameters = JsonSerializer.Serialize(parameters); 156return JsonSerializer.SerializeToElement(intValue); 161return JsonSerializer.SerializeToElement(doubleValue); 167return JsonSerializer.SerializeToElement(boolValue); 171return JsonSerializer.SerializeToElement(content);

Microsoft.Extensions.AI.OpenAI (22)

MicrosoftExtensionsAIChatExtensions.cs (3)

71new BinaryData(JsonSerializer.SerializeToUtf8Bytes(c.Arguments, AIJsonUtilities.DefaultOptions.GetTypeInfo(typeof(IDictionary<string, object?>)))))); 153new(JsonSerializer.SerializeToUtf8Bytes(fcc.Arguments, AIJsonUtilities.DefaultOptions.GetTypeInfo(typeof(IDictionary<string, object?>)))))) 232return JsonSerializer.Deserialize(ms.GetBuffer().AsSpan(0, (int)ms.Position), AIJsonUtilities.DefaultOptions.GetTypeInfo(typeof(JsonElement)))!;

OpenAIAssistantsChatClient.cs (3)

190JsonSerializer.Serialize([ru.Value.Id, toolCallId], OpenAIJsonContext.Default.StringArray), 418BinaryData.FromBytes(JsonSerializer.SerializeToUtf8Bytes(jsonSchema, OpenAIJsonContext.Default.JsonElement)), 527runAndCallIDs = JsonSerializer.Deserialize(frc.CallId, OpenAIJsonContext.Default.StringArray);

OpenAIChatClient.cs (3)

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

OpenAIClientExtensions.cs (4)

189var tool = JsonSerializer.Deserialize(jsonSchema, OpenAIJsonContext.Default.ToolJson)!; 190var functionParameters = BinaryData.FromBytes(JsonSerializer.SerializeToUtf8Bytes(tool, OpenAIJsonContext.Default.ToolJson)); 204static json => JsonSerializer.Deserialize(json, OpenAIJsonContext.Default.IDictionaryStringObject)!); 215static utf8json => JsonSerializer.Deserialize(utf8json, OpenAIJsonContext.Default.IDictionaryStringObject)!);

OpenAIImageGenerator.cs (1)

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

OpenAIResponsesChatClient.cs (8)

196Arguments = JsonSerializer.Deserialize(mtcari.ToolArguments.ToMemory().Span, OpenAIJsonContext.Default.IReadOnlyDictionaryStringObject)!, 378Arguments = JsonSerializer.Deserialize(mtcari.ToolArguments.ToMemory().Span, OpenAIJsonContext.Default.IReadOnlyDictionaryStringObject)!, 632BinaryData.FromBytes(JsonSerializer.SerializeToUtf8Bytes(jsonSchema, OpenAIJsonContext.Default.JsonElement)), 777result = JsonSerializer.Serialize(resultContent.Result, AIJsonUtilities.DefaultOptions.GetTypeInfo(typeof(object))); 823BinaryData.FromBytes(JsonSerializer.SerializeToUtf8Bytes( 833BinaryData.FromBytes(JsonSerializer.SerializeToUtf8Bytes(mcpApprovalRequestContent.ToolCall.Arguments!, OpenAIJsonContext.Default.IReadOnlyDictionaryStringObject))); 848BinaryData.FromBytes(JsonSerializer.SerializeToUtf8Bytes(associatedCall.Arguments!, OpenAIJsonContext.Default.IReadOnlyDictionaryStringObject))); 990Arguments = JsonSerializer.Deserialize(mtci.ToolArguments.ToMemory().Span, OpenAIJsonContext.Default.IReadOnlyDictionaryStringObject)!,

Microsoft.Extensions.AI.OpenAI.Tests (9)

OpenAIConversionTests.cs (6)

207Assert.True(JsonElement.DeepEquals(JsonSerializer.SerializeToElement(new Dictionary<string, object?> 211}), JsonSerializer.Deserialize<JsonElement>(tc.FunctionArguments.ToMemory().Span))); 263Assert.True(JsonElement.DeepEquals(JsonSerializer.SerializeToElement(new Dictionary<string, object?> 267}), JsonSerializer.Deserialize<JsonElement>(m3.FunctionArguments.ToMemory().Span))); 597var deserializedArgs = JsonSerializer.Deserialize<Dictionary<string, object?>>(toolCall.FunctionArguments.ToMemory().Span); 792var deserializedArgs = JsonSerializer.Deserialize<Dictionary<string, object?>>(

test\Libraries\Microsoft.Extensions.AI.Abstractions.Tests\AssertExtensions.cs (3)

Microsoft.Extensions.AI.Tests (24)

ChatCompletion\ChatClientStructuredOutputExtensionsTests.cs (9)

ChatCompletion\DistributedCachingChatClientTest.cs (6)

802JsonSerializer.Serialize(expected.AdditionalProperties, TestJsonSerializerContext.Default.Options), 803JsonSerializer.Serialize(actual.AdditionalProperties, TestJsonSerializerContext.Default.Options)); 827JsonSerializer.Serialize(expectedFcc.Arguments, TestJsonSerializerContext.Default.Options), 828JsonSerializer.Serialize(actualFcc.Arguments, TestJsonSerializerContext.Default.Options)); 861JsonSerializer.Serialize(expectedFcc.Arguments, TestJsonSerializerContext.Default.Options), 862JsonSerializer.Serialize(actualFcc.Arguments, TestJsonSerializerContext.Default.Options));

ChatCompletion\FunctionInvokingChatClientTests.cs (3)

346JsonSerializer.SerializeToElement($"{e.GetString()} from delegate", AIJsonUtilities.DefaultOptions) : 710JsonSerializer.Serialize(new Dictionary<string, object?> { ["arg1"] = "value1" }, AIJsonUtilities.DefaultOptions), 714Assert.Equal("Result 1", JsonSerializer.Deserialize<string>(result.Value!, AIJsonUtilities.DefaultOptions));

Embeddings\DistributedCachingEmbeddingGeneratorTest.cs (2)

408JsonSerializer.Serialize(expected.AdditionalProperties, TestJsonSerializerContext.Default.Options), 409JsonSerializer.Serialize(actual.AdditionalProperties, TestJsonSerializerContext.Default.Options));

Functions\AIFunctionFactoryTest.cs (1)

135JsonElement expectedResult = JsonDocument.Parse(JsonSerializer.Serialize(invalidJsonParam, JsonContext.Default.String)).RootElement;

test\Libraries\Microsoft.Extensions.AI.Abstractions.Tests\AssertExtensions.cs (3)

Microsoft.Extensions.Caching.Hybrid (2)

Internal\DefaultJsonSerializerFactory.cs (2)

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

Microsoft.Extensions.Caching.Hybrid.Tests (2)

SampleUsage.cs (2)

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

Microsoft.Extensions.DotNetDeltaApplier.Tests (3)

AbstractBrowserRefreshServer.cs (3)

Microsoft.Extensions.Validation.GeneratorTests (1)

ValidationsGeneratorTestBase.cs (1)

589return JsonSerializer.Deserialize<HttpValidationProblemDetails>(responseBody);

Microsoft.JSInterop (8)

Infrastructure\DotNetDispatcher.cs (4)

64return JsonSerializer.Serialize(syncResult, jsRuntime.JsonSerializerOptions); 135var syncResultJson = JsonSerializer.Serialize(syncResult, jsRuntime.JsonSerializerOptions); 152var resultJson = JsonSerializer.Serialize(result, jsRuntime.JsonSerializerOptions); 246suppliedArgs[index] = JsonSerializer.Deserialize(ref reader, parameterType, jsRuntime.JsonSerializerOptions);

JSInProcessRuntime.cs (2)

47var argsJson = args is not null && args.Length != 0 ? JsonSerializer.Serialize(args, JsonSerializerOptions) : "[]"; 69var result = JsonSerializer.Deserialize<TValue>(resultJson, JsonSerializerOptions)!;

JSRuntime.cs (2)

153var argsJson = args is not null && args.Length != 0 ? JsonSerializer.Serialize(args, JsonSerializerOptions) : "[]"; 291var result = JsonSerializer.Deserialize(ref jsonReader, resultType, JsonSerializerOptions);

Microsoft.JSInterop.Tests (59)

Infrastructure\ByteArrayJsonConverterTest.cs (15)

Infrastructure\DotNetDispatcherTest.cs (17)

Infrastructure\DotNetObjectReferenceJsonConverterTest.cs (9)

Infrastructure\DotNetStreamReferenceJsonConverterTest.cs (3)

26var ex = Assert.Throws<NotSupportedException>(() => JsonSerializer.Deserialize<DotNetStreamReference>(json, JsonSerializerOptions)); 37var json = JsonSerializer.Serialize(streamRef, JsonSerializerOptions); 52var json = JsonSerializer.Serialize(streamRef, JsonSerializerOptions);

Infrastructure\JSObjectReferenceJsonConverterTest.cs (7)

27var ex = Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<IJSObjectReference>(json, JsonSerializerOptions)); 38var ex = Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<IJSObjectReference>(json, JsonSerializerOptions)); 49var ex = Record.Exception(() => JsonSerializer.Deserialize<IJSObjectReference>(json, JsonSerializerOptions)); 60var ex = Record.Exception(() => JsonSerializer.Deserialize<IJSObjectReference>(json, JsonSerializerOptions)); 72var deserialized = (JSObjectReference)JsonSerializer.Deserialize<IJSObjectReference>(json, JsonSerializerOptions)!; 85var json = JsonSerializer.Serialize((IJSObjectReference)jsObjectRef, JsonSerializerOptions); 98var deserialized = JsonSerializer.Deserialize<IJSObjectReference>(json, JsonSerializerOptions);

Infrastructure\JSStreamReferenceJsonConverterTest.cs (8)

Microsoft.Maui (7)

Handlers\HybridWebView\HybridWebViewHandler.cs (7)

150 var jsError = JsonSerializer.Deserialize(result, HybridWebViewHandlerJsonContext.Default.JSInvokeError); 184 var invokeData = JsonSerializer.Deserialize<JSInvokeMethodData>(invokeDataString, HybridWebViewHandlerJsonContext.Default.JSInvokeMethodData); 192 var json = JsonSerializer.Serialize(invokeResult); 219 Result = JsonSerializer.Serialize(result), 260 var deserialized = JsonSerializer.Deserialize(reqValue, paramType); 408 invokeJavaScriptRequest.ParamValues.Select((v, i) => (v == null ? "null" : JsonSerializer.Serialize(v, invokeJavaScriptRequest.ParamJsonTypeInfos![i]!)))); 428 var typedResult = JsonSerializer.Deserialize(stringResult, invokeJavaScriptRequest.ReturnTypeJsonTypeInfo);

Microsoft.ML.AutoML (5)

AutoMLExperiment\AutoMLExperiment.cs (4)

272logger.Trace($"trial setting - {JsonSerializer.Serialize(trialSettings)}"); 299Exception thrown during Trial {trialSettings.TrialId} with configuration {JsonSerializer.Serialize(trialSettings)} 320logger.Trace($"trial fatal error - {JsonSerializer.Serialize(trialSettings)}, stop training"); 332logger.Trace($"trial cancelled - {JsonSerializer.Serialize(trialSettings)}, stop training");

Tuner\AutoZeroTuner.cs (1)

73var res = JsonSerializer.Deserialize<List<Config>>(json);

Microsoft.ML.AutoML.Interactive (4)

AutoMLMonitorKernelExtension.cs (3)

25Formatter.Register<Parameter>((parameter) => JsonSerializer.Serialize(parameter, new JsonSerializerOptions() { WriteIndented = true, })); 52var bestTrialParam = JsonSerializer.Serialize(monitor.BestTrial.TrialSettings.Parameter, new JsonSerializerOptions() { WriteIndented = true, }); 61var activeTrialParam = JsonSerializer.Serialize(monitor.ActiveTrial.Parameter, new JsonSerializerOptions() { WriteIndented = true, });

NotebookMonitor.cs (1)

47var activeRunParam = JsonSerializer.Serialize(result.TrialSettings.Parameter, new JsonSerializerOptions() { WriteIndented = false, });

Microsoft.ML.AutoML.SourceGenerator (5)

EstimatorTypeGenerator.cs (1)

28var flags = JsonSerializer.Deserialize<Dictionary<string, bool>>(json);

SearchSpaceGenerator.cs (1)

25var flags = JsonSerializer.Deserialize<Dictionary<string, bool>>(json);

SweepableEstimatorFactoryGenerator.cs (1)

25var flags = JsonSerializer.Deserialize<Dictionary<string, bool>>(json);

SweepableEstimatorGenerator.cs (1)

24var flags = JsonSerializer.Deserialize<Dictionary<string, bool>>(json);

Utils.cs (1)

17return JsonSerializer.Deserialize<EstimatorsContract>(json);

Microsoft.ML.AutoML.Tests (17)

AutoFeaturizerTests.cs (6)

50Approvals.Verify(JsonSerializer.Serialize(pipeline, _jsonSerializerOptions)); 62Approvals.Verify(JsonSerializer.Serialize(pipeline, _jsonSerializerOptions)); 74Approvals.Verify(JsonSerializer.Serialize(pipeline, _jsonSerializerOptions)); 86Approvals.Verify(JsonSerializer.Serialize(pipeline, _jsonSerializerOptions)); 97Approvals.Verify(JsonSerializer.Serialize(pipeline, _jsonSerializerOptions)); 113Approvals.Verify(JsonSerializer.Serialize(pipeline, _jsonSerializerOptions));

SweepableEstimatorPipelineTest.cs (1)

122Approvals.Verify(JsonSerializer.Serialize(defaultParam, _jsonSerializerOptions));

SweepableExtensionTest.cs (9)

SweepablePipelineTests.cs (1)

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

Microsoft.ML.GenAI.LLaMA (7)

LlamaConfig.cs (5)

52Llama3_1_8B_Instruct = JsonSerializer.Deserialize<LlamaConfig>(llama3_1_8b_content) ?? throw new ArgumentNullException(nameof(llama3_1_8b_content)); 53Llama3_1_70B_Instruct = JsonSerializer.Deserialize<LlamaConfig>(llama3_1_70b_content) ?? throw new ArgumentNullException(nameof(llama3_1_70b_content)); 54Llama3_1_405B_Instruct = JsonSerializer.Deserialize<LlamaConfig>(llama3_1_405b_content) ?? throw new ArgumentNullException(nameof(llama3_1_405b_content)); 55Llama3_2_1B_Instruct = JsonSerializer.Deserialize<LlamaConfig>(llama3_2_1b_content) ?? throw new ArgumentNullException(nameof(llama3_2_1b_content)); 56Llama_3_2_3B_Instruct = JsonSerializer.Deserialize<LlamaConfig>(llama3_2_3b_content) ?? throw new ArgumentNullException(nameof(llama3_2_3b_content));

LlamaForCausalLM.cs (2)

103var modelConfig = JsonSerializer.Deserialize<LlamaConfig>(File.ReadAllText(config)) ?? throw new ArgumentNullException(nameof(config)); 136var modelConfig = JsonSerializer.Deserialize<LlamaConfig>(File.ReadAllText(config)) ?? throw new ArgumentNullException(nameof(config));

Microsoft.ML.GenAI.Mistral (8)

Mistral_7B_0_3ChatTemplateBuilder.cs (3)

77var schemaPrompt = JsonSerializer.Serialize(schemas); 130var toolCallJson = JsonSerializer.Serialize(toolCallObjects); 152var toolCallResultJson = JsonSerializer.Serialize(toolCallResultObjects);

MistralCausalLMAgent.cs (2)

149var mistralToolCalls = JsonSerializer.Deserialize<List<MistralToolCall>>(json) ?? throw new InvalidOperationException("Failed to deserialize tool calls."); 151.Select(tc => new ToolCall(tc.Name!, JsonSerializer.Serialize(tc.Arguments)) { ToolCallId = this.GenerateToolCallId() });

MistralConfig.cs (1)

44Mistral_7B_Instruct_v0_3 = JsonSerializer.Deserialize<MistralConfig>(mistral7BInstructContent) ?? throw new ArgumentNullException(nameof(mistral7BInstructContent));

MistralForCausalLM.cs (2)

58var modelConfig = JsonSerializer.Deserialize<MistralConfig>(File.ReadAllText(config)) ?? throw new ArgumentNullException(nameof(config)); 86var modelConfig = JsonSerializer.Deserialize<MistralConfig>(File.ReadAllText(config)) ?? throw new ArgumentNullException(nameof(config));

Microsoft.ML.GenAI.Phi (8)

Phi2\Config.cs (1)

45var phi2Config = JsonSerializer.Deserialize<Phi2Config>(phi2ConfigContent) ?? throw new ArgumentNullException(nameof(phi2ConfigContent));

Phi2\Phi2ForCausalLM.cs (1)

59var modelConfig = JsonSerializer.Deserialize<Phi2Config>(File.ReadAllText(config)) ?? throw new ArgumentNullException(nameof(config));

Phi3\Config.cs (4)

51Phi3Mini4kInstruct = JsonSerializer.Deserialize<Phi3Config>(phi3Mini4kInstructContent) ?? throw new ArgumentNullException(nameof(phi3Mini4kInstructContent)); 52Phi3Mini128kInstruct = JsonSerializer.Deserialize<Phi3Config>(phi3Mini128kInstructContent) ?? throw new ArgumentNullException(nameof(phi3Mini128kInstructContent)); 53Phi3Medium4kInstruct = JsonSerializer.Deserialize<Phi3Config>(phi3Medium4kInstructContent) ?? throw new ArgumentNullException(nameof(phi3Medium4kInstructContent)); 54Phi3Medium128kInstruct = JsonSerializer.Deserialize<Phi3Config>(phi3Medium128kInstructContent) ?? throw new ArgumentNullException(nameof(phi3Medium128kInstructContent));

Phi3\Phi3ForCausalLM.cs (2)

60var modelConfig = JsonSerializer.Deserialize<Phi3Config>(File.ReadAllText(config)) ?? throw new ArgumentNullException(nameof(config)); 88var modelConfig = JsonSerializer.Deserialize<Phi3Config>(File.ReadAllText(config)) ?? throw new ArgumentNullException(nameof(config));

Microsoft.ML.GenAI.Phi.Tests (1)

Phi3Tests.cs (1)

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

Microsoft.ML.GenAI.Samples (2)

Mistral\Mistral_7B_Instruct.cs (1)

76var mistralConfig = JsonSerializer.Deserialize<MistralConfig>(File.ReadAllText(Path.Combine(weightFolder, configName))) ?? throw new ArgumentNullException(nameof(configName));

Mistral_7B_Instruct_8c038b96-7961-4e41-93b7-d4173f32005f.generated.cs (1)

25var schema = JsonSerializer.Deserialize<GetWeatherSchema>(

Microsoft.ML.SearchSpace (24)

Converter\ChoiceOptionConverter.cs (2)

30var schema = JsonSerializer.Deserialize<Schema>(ref reader, options); 43JsonSerializer.Serialize(writer, schema, options);

Converter\NumericOptionConverter.cs (2)

39var schema = JsonSerializer.Deserialize<Schema>(ref reader, options); 81JsonSerializer.Serialize(writer, schema, options);

Converter\OptionConverter.cs (6)

20return JsonSerializer.Deserialize<SearchSpace>(ref reader, options); 29return JsonSerializer.Deserialize<ChoiceOption>(ref reader, options); 38return JsonSerializer.Deserialize<UniformNumericOption>(ref reader, options); 50JsonSerializer.Serialize(writer, ss, options); 54JsonSerializer.Serialize(writer, choiceOption, options); 58JsonSerializer.Serialize(writer, uniformNumericOption, options);

Converter\ParameterConverter.cs (4)

20var array = JsonSerializer.Deserialize<Dictionary<string, Parameter>>(ref reader, options).ToArray(); 23return Parameter.FromString(JsonSerializer.Deserialize<string>(ref reader, options)); 34return Parameter.FromDouble(JsonSerializer.Deserialize<double>(ref reader, options)); 56JsonSerializer.Serialize(writer, value.Value, options);

Converter\SearchSpaceConverter.cs (2)

18var optionKVPairs = JsonSerializer.Deserialize<Dictionary<string, OptionBase>>(ref reader, options); 25JsonSerializer.Serialize<IDictionary<string, OptionBase>>(value, options);

Parameter.cs (7)

286/// Cast <see cref="ParameterType"/> to <typeparamref name="T"/>. This method will return immediately if the underlying value is of type <typeparamref name="T"/>, otherwise it uses <see cref="JsonSerializer"/> to 297var json = JsonSerializer.Serialize(_value, _settings); 298return JsonSerializer.Deserialize<T>(json, _settings); 393var thisJson = JsonSerializer.Serialize(this); 394var otherJson = JsonSerializer.Serialize(other); 402var thisJson = JsonSerializer.Serialize(this); 426return JsonSerializer.Serialize(this);

SearchSpace.cs (1)

157var json = JsonSerializer.Serialize(parameter);

Microsoft.ML.SearchSpace.Tests (6)

ParameterTest.cs (5)

40var json = JsonSerializer.Serialize(parameter, _settings); 43parameter = JsonSerializer.Deserialize<Parameter>(json); 109var json = JsonSerializer.Serialize(parameter, _settings); 112parameter = JsonSerializer.Deserialize<Parameter>(json); 119json = JsonSerializer.Serialize(parameter, _settings);

SearchSpaceTest.cs (1)

303var json = JsonSerializer.Serialize(ss, _settings);

Microsoft.ML.Tokenizers (5)

Model\BpeOptions.cs (1)

50Dictionary<string, int>? dictionary = JsonSerializer.Deserialize<Dictionary<string, int>>(vocabStream);

Model\BPETokenizer.cs (2)

1102? await JsonSerializer.DeserializeAsync(vocab, ModelSourceGenerationContext.Default.DictionaryStringSpanOrdinalKeyInt32, cancellationToken).ConfigureAwait(false) 1103: JsonSerializer.Deserialize(vocab, ModelSourceGenerationContext.Default.DictionaryStringSpanOrdinalKeyInt32);

Model\CodeGenTokenizer.cs (1)

1752vocab = JsonSerializer.Deserialize(vocabularyStream, ModelSourceGenerationContext.Default.Vocabulary);

Model\EnglishRobertaTokenizer.cs (1)

184vocab = JsonSerializer.Deserialize(vocabularyStream, ModelSourceGenerationContext.Default.DictionaryStringSpanOrdinalKeyInt32);

Microsoft.ML.Tokenizers.Tests (8)

BpeTests.cs (2)

400Dictionary<string, int>? dictionary = JsonSerializer.Deserialize<Dictionary<string, int>>(jsonString); 592File.WriteAllText(fileName, JsonSerializer.Serialize<Dictionary<string, int>>(dic), Encoding.UTF8);

TiktokenTests.cs (6)

225int[]? expected = JsonSerializer.Deserialize<int[]>(stream) as int[]; 300int[]? expected = JsonSerializer.Deserialize<int[]>(stream) as int[]; 337int[]? expected = JsonSerializer.Deserialize<int[]>(stream) as int[]; 356int[]? expected = JsonSerializer.Deserialize<int[]>(stream) as int[]; 375int[]? expected = JsonSerializer.Deserialize<int[]>(stream) as int[]; 394int[]? expected = JsonSerializer.Deserialize<int[]>(stream) as int[];

Microsoft.NET.Build.Containers.UnitTests (1)

DescriptorTests.cs (1)

18Console.WriteLine(JsonSerializer.Serialize(d, new JsonSerializerOptions { WriteIndented = true }));

Microsoft.NET.Build.Tasks (4)

InstallStateContents.cs (2)

35return JsonSerializer.Deserialize<InstallStateContents>(contents, s_options) ?? new InstallStateContents(); 45return JsonSerializer.Serialize(this, s_options);

WorkloadSet.cs (2)

Microsoft.NET.Sdk.BlazorWebAssembly.AoT.Tests (6)

BootJsonData.cs (5)

411BootJsonData config = JsonSerializer.Deserialize<BootJsonData>(jsonContent, options); 500return JsonSerializer.Deserialize<AssetsData>(ref reader, nestedOptions)!; 504return JsonSerializer.Deserialize<ResourcesData>(ref reader, nestedOptions)!; 508return JsonSerializer.Deserialize<object>(ref reader, nestedOptions)!; 513JsonSerializer.Serialize(writer, value, value.GetType(), options);

ServiceWorkerAssert.cs (1)

81return JsonSerializer.Deserialize<AssetsManifestFile>(json);

Microsoft.NET.Sdk.BlazorWebAssembly.Tests (15)

AspNetSdkBaselineTest.cs (4)

163JsonSerializer.Serialize(existingFiles, BaselineSerializationOptions)); 256JsonSerializer.Serialize(existingFiles, BaselineSerializationOptions)); 268return JsonSerializer.Deserialize<string[]>(filesBaselineStream); 323return JsonSerializer.Serialize(manifest, BaselineSerializationOptions);

BootJsonData.cs (5)

ServiceWorkerAssert.cs (1)

81return JsonSerializer.Deserialize<AssetsManifestFile>(json);

WasmJsModulesIntegrationTests.cs (5)

44var contents = JsonSerializer.Deserialize<JsonDocument>(BootJsonDataLoader.GetJsonContent(blazorBootJson.FullName)); 89var contents = JsonSerializer.Deserialize<JsonDocument>(BootJsonDataLoader.GetJsonContent(blazorBootJson.FullName)); 133var contents = JsonSerializer.Deserialize<JsonDocument>(BootJsonDataLoader.GetJsonContent(blazorBootJson.FullName)); 344var contents = JsonSerializer.Deserialize<JsonDocument>(BootJsonDataLoader.GetJsonContent(path)); 356var contents = JsonSerializer.Deserialize<JsonDocument>(BootJsonDataLoader.GetJsonContent(path));

Microsoft.NET.Sdk.Publish.Tasks (4)

AppSettingsTransform.cs (2)

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

Tasks\Http\HttpClientExtensions.cs (1)

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

Tasks\ZipDeploy\ZipDeploymentStatus.cs (1)

120return JsonSerializer.Deserialize<T>(jsonString,

Microsoft.NET.Sdk.Publish.Tasks.Tests (2)

Tasks\OneDeploy\OneDeployStatusServiceTests.cs (1)

225deploymentResponseJson = JsonSerializer.Serialize(deploymentResponse);

Tasks\ZipDeploy\ZipDeploymentStatusTests.cs (1)

85string statusJson = JsonSerializer.Serialize(deploymentResponse);

Microsoft.NET.Sdk.StaticWebAssets.Tasks (28)

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)

134var 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>";

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

Microsoft.NET.Sdk.StaticWebAssets.Tests (9)

AspNetSdkBaselineTest.cs (4)

StaticWebAssetEndpointsIntegrationTest.cs (2)

518var endpoints = JsonSerializer.Deserialize<StaticWebAssetEndpointsManifest>(File.ReadAllText(endpointsManifestFile)); 560var staticWebAssetDevelopmentManifest = JsonSerializer.Deserialize<StaticWebAssetsDevelopmentManifest>(File.ReadAllText(Path.Combine(outputDirectory, $"{projectName}.staticwebassets.runtime.json")));

StaticWebAssets\GenerateStaticWebAssetEndpointsManifestTest.cs (2)

205var json = JsonSerializer.Deserialize<StaticWebAssetEndpointsManifest>(manifest); 258var json = JsonSerializer.Deserialize<StaticWebAssetEndpointsManifest>(manifest);

StaticWebAssetsFingerprintingTest.cs (1)

132var endpoints = JsonSerializer.Deserialize<StaticWebAssetEndpointsManifest>(File.ReadAllText(endpointsManifestPath));

Microsoft.NET.Sdk.WorkloadManifestReader (4)

InstallStateContents.cs (2)

35return JsonSerializer.Deserialize<InstallStateContents>(contents, s_options) ?? new InstallStateContents(); 45return JsonSerializer.Serialize(this, s_options);

WorkloadSet.cs (2)

Microsoft.WebTools.AspireService.Package (1)

AspireServerService.cs (1)

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

Microsoft.WebTools.AspireService.Tests (5)

AspireServerService.cs (1)

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

AspireServerServiceTests.cs (4)

401var notification = JsonSerializer.Deserialize<SessionNotification>(message, AspireServerService.JsonSerializerOptions); 406NotificationType.ProcessRestarted => JsonSerializer.Deserialize<ProcessRestartedNotification>(message, AspireServerService.JsonSerializerOptions), 407NotificationType.SessionTerminated => JsonSerializer.Deserialize<SessionTerminatedNotification>(message, AspireServerService.JsonSerializerOptions), 408NotificationType.ServiceLogs => JsonSerializer.Deserialize<ServiceLogsNotification>(message, AspireServerService.JsonSerializerOptions),

OrderProcessor (1)

OrderProcessingWorker.cs (1)

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

RunTests (1)

AssemblyScheduler.cs (1)

257var deserialized = JsonSerializer.Deserialize<List<string>>(File.ReadAllText(testListPath));

Shared.Tests (3)

JsonSchemaExporter\JsonSchemaExporterTests.cs (1)

47JsonNode? instance = JsonSerializer.SerializeToNode(testData.Value, testData.Type, options);

JsonSchemaExporter\SchemaTestHelpers.cs (2)

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

System.Memory.Data (14)

System\BinaryData.cs (14)

System.Net.Http.Json (14)

System\Net\Http\Json\HttpClientJsonExtensions.cs (4)

20FromJsonAsyncCore(getMethod, client, requestUri, static (stream, options, cancellation) => JsonSerializer.DeserializeAsync(stream, options.type, options.options ?? JsonSerializerOptions.Web, cancellation), (type, options), cancellationToken); 25FromJsonAsyncCore(getMethod, client, requestUri, static (stream, options, cancellation) => JsonSerializer.DeserializeAsync<TValue>(stream, options ?? JsonSerializerOptions.Web, cancellation), options, cancellationToken); 28FromJsonAsyncCore(getMethod, client, requestUri, static (stream, options, cancellation) => JsonSerializer.DeserializeAsync(stream, options.type, options.context, cancellation), (type, context), cancellationToken); 31FromJsonAsyncCore(getMethod, client, requestUri, static (stream, options, cancellation) => JsonSerializer.DeserializeAsync(stream, options, cancellation), jsonTypeInfo, cancellationToken);

System\Net\Http\Json\HttpClientJsonExtensions.Get.AsyncEnumerable.cs (1)

166await foreach (TValue? value in JsonSerializer.DeserializeAsyncEnumerable<TValue>(

System\Net\Http\Json\HttpContentJsonExtensions.AsyncEnumerable.cs (1)

101await foreach (TValue? value in JsonSerializer.DeserializeAsyncEnumerable<TValue>(

System\Net\Http\Json\HttpContentJsonExtensions.cs (4)

88return await JsonSerializer.DeserializeAsync(contentStream, type, options ?? JsonSerializerOptions.Web, cancellationToken).ConfigureAwait(false); 98return await JsonSerializer.DeserializeAsync<T>(contentStream, options ?? JsonSerializerOptions.Web, cancellationToken).ConfigureAwait(false); 120return await JsonSerializer.DeserializeAsync(contentStream, type, context, cancellationToken).ConfigureAwait(false); 128return await JsonSerializer.DeserializeAsync(contentStream, jsonTypeInfo, cancellationToken).ConfigureAwait(false);

System\Net\Http\Json\JsonContent.cs (3)

119: JsonSerializer.SerializeAsync(targetStream, Value, _typeInfo, cancellationToken); 131await JsonSerializer.SerializeAsync(transcodingStream, Value, _typeInfo, cancellationToken).ConfigureAwait(false); 135JsonSerializer.Serialize(transcodingStream, Value, _typeInfo);

System\Net\Http\Json\JsonContent.netcoreapp.cs (1)

22JsonSerializer.Serialize(stream, Value, _typeInfo);

System.Private.Windows.Core (6)

System\Private\Windows\JsonData.cs (2)

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

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

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

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

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

System.Private.Windows.Core.Tests (1)

System\Private\Windows\Ole\NativeToManagedAdapterTests.cs (1)

102BinaryFormatWriter.TryWriteJsonData(stream, new JsonData<int[]>() { JsonBytes = JsonSerializer.SerializeToUtf8Bytes(new int[] { 0xBE, 0xAD }) });

System.Text.Json (175)

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

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

src\libraries\System.Text.Json\Common\JsonSourceGenerationMode.cs (2)

23/// This mode supports all <see cref="JsonSerializer"/> features. 31/// This mode supports only a subset of <see cref="JsonSerializer"/> features.

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

7/// Determines how <see cref="JsonSerializer"/> handles JSON properties that

System\Text\Json\Nodes\JsonNode.cs (2)

372[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 373[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]

System\Text\Json\Nodes\JsonValueOfTCustomized.cs (1)

27internal override JsonNode DeepCloneCore() => JsonSerializer.SerializeToNode(Value, _jsonTypeInfo)!;

System\Text\Json\Schema\JsonSchemaExporter.cs (2)

238propertySchema.DefaultValue = JsonSerializer.SerializeToNode(parameterInfo.DefaultValue, property.JsonTypeInfo); 283const string ValuesKeyword = JsonSerializer.ValuesPropertyName;

System\Text\Json\Serialization\Attributes\JsonNumberHandlingAttribute.cs (1)

23if (!JsonSerializer.IsValidNumberHandlingValue(handling))

System\Text\Json\Serialization\Attributes\JsonObjectCreationHandlingAttribute.cs (1)

45if (!JsonSerializer.IsValidCreationHandlingValue(handling))

System\Text\Json\Serialization\Converters\CastingConverter.cs (5)

45=> JsonSerializer.UnboxOnRead<T>(_sourceConverter.ReadAsObject(ref reader, typeToConvert, options)); 53value = JsonSerializer.UnboxOnRead<T>(sourceValue); 61=> JsonSerializer.UnboxOnRead<T>(_sourceConverter.ReadAsPropertyNameAsObject(ref reader, typeToConvert, options))!; 64=> JsonSerializer.UnboxOnRead<T>(_sourceConverter.ReadAsPropertyNameCoreAsObject(ref reader, typeToConvert, options))!; 73=> JsonSerializer.UnboxOnRead<T>(_sourceConverter.ReadNumberWithCustomHandlingAsObject(ref reader, handling, options))!;

System\Text\Json\Serialization\Converters\Collection\IAsyncEnumerableConverterFactory.cs (1)

15[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]

System\Text\Json\Serialization\Converters\Collection\IEnumerableConverterFactory.cs (2)

18[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 25[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)]

System\Text\Json\Serialization\Converters\Collection\JsonCollectionConverter.cs (5)

146if (!JsonSerializer.TryReadMetadata(this, jsonTypeInfo, ref reader, ref state)) 154value = JsonSerializer.ResolveReferenceId<TCollection>(ref state); 177JsonSerializer.ValidateMetadataForArrayConverter(this, ref reader, ref state); 269Debug.Assert(JsonSerializer.IsMetadataPropertyName(reader.GetUnescapedSpan(), (state.Current.BaseJsonTypeInfo ?? jsonTypeInfo).PolymorphicTypeResolver), "should only be hit if metadata property."); 316state.Current.MetadataPropertyName = JsonSerializer.WriteMetadataForCollection(this, ref state, writer);

System\Text\Json\Serialization\Converters\Collection\JsonDictionaryConverter.cs (5)

168if (!JsonSerializer.TryReadMetadata(this, jsonTypeInfo, ref reader, ref state)) 176value = JsonSerializer.ResolveReferenceId<TDictionary>(ref state); 200JsonSerializer.ValidateMetadataForObjectConverter(ref state); 253if (JsonSerializer.IsMetadataPropertyName(propertyName, state.Current.BaseJsonTypeInfo.PolymorphicTypeResolver)) 358JsonSerializer.WriteMetadataForObject(this, ref state, writer);

System\Text\Json\Serialization\Converters\Collection\MemoryConverterFactory.cs (1)

10[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]

System\Text\Json\Serialization\Converters\Collection\StackOrQueueConverterWithReflection.cs (4)

15[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 16[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 19[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 20[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]

System\Text\Json\Serialization\Converters\Object\ObjectConverter.cs (2)

118JsonSerializer.TryHandleReferenceFromJsonElement(ref reader, ref state, element, out referenceValue)) 135JsonSerializer.TryHandleReferenceFromJsonNode(ref reader, ref state, node, out referenceValue))

System\Text\Json\Serialization\Converters\Object\ObjectConverterFactory.cs (2)

17[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 23[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)]

System\Text\Json\Serialization\Converters\Object\ObjectDefaultConverter.cs (10)

71if (!JsonSerializer.TryReadMetadata(this, jsonTypeInfo, ref reader, ref state)) 79value = JsonSerializer.ResolveReferenceId<T>(ref state); 102JsonSerializer.ValidateMetadataForObjectConverter(ref state); 107value = JsonSerializer.ResolveReferenceId<T>(ref state); 175ReadOnlySpan<byte> unescapedPropertyName = JsonSerializer.GetPropertyName(ref state, ref reader, options, out bool isAlreadyReadMetadataProperty); 184jsonPropertyInfo = JsonSerializer.LookupProperty( 292ReadOnlySpan<byte> unescapedPropertyName = JsonSerializer.GetPropertyName(ref state, ref reader, options, out bool isAlreadyReadMetadataProperty); 296JsonPropertyInfo jsonPropertyInfo = JsonSerializer.LookupProperty( 335JsonSerializer.WriteMetadataForObject(this, ref state, writer); 378JsonSerializer.WriteMetadataForObject(this, ref state, writer);

System\Text\Json\Serialization\Converters\Object\ObjectWithParameterizedConstructorConverter.cs (9)

106JsonSerializer.CreateExtensionDataProperty(obj, jsonPropertyInfo, options); 134if (!JsonSerializer.TryReadMetadata(this, jsonTypeInfo, ref reader, ref state)) 142value = JsonSerializer.ResolveReferenceId<T>(ref state); 180JsonSerializer.ValidateMetadataForObjectConverter(ref state); 185value = JsonSerializer.ResolveReferenceId<T>(ref state); 238JsonSerializer.CreateExtensionDataProperty(obj, jsonPropertyInfo, options); 318ReadOnlySpan<byte> unescapedPropertyName = JsonSerializer.GetPropertyName(ref state, ref reader, options, out bool isAlreadyReadMetadataProperty); 428ReadOnlySpan<byte> unescapedPropertyName = JsonSerializer.GetPropertyName(ref state, ref reader, options, out bool isAlreadyReadMetadataProperty); 623jsonPropertyInfo = JsonSerializer.LookupProperty(

System\Text\Json\Serialization\Converters\Object\ObjectWithParameterizedConstructorConverter.Large.Reflection.cs (4)

17[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 18[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 23[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 24[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]

System\Text\Json\Serialization\Converters\Object\ObjectWithParameterizedConstructorConverter.Small.cs (2)

122[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 123[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]

System\Text\Json\Serialization\Converters\Value\EnumConverterFactory.cs (1)

10[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]

System\Text\Json\Serialization\Converters\Value\NullableConverterFactory.cs (1)

11[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]

System\Text\Json\Serialization\Converters\Value\UnsupportedTypeConverterFactory.cs (1)

11[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]

System\Text\Json\Serialization\JsonConverter.cs (2)

234[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 235[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]

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

170if (canHaveIdMetadata && JsonSerializer.TryGetReferenceForValue(value, ref state, writer))

System\Text\Json\Serialization\JsonConverterOfT.cs (6)

79T valueOfT = JsonSerializer.UnboxOnWrite<T>(value)!; 86T valueOfT = JsonSerializer.UnboxOnWrite<T>(value)!; 93T valueOfT = JsonSerializer.UnboxOnWrite<T>(value)!; 99T valueOfT = JsonSerializer.UnboxOnWrite<T>(value)!; 105T valueOfT = JsonSerializer.UnboxOnWrite<T>(value)!; 112T valueOfT = JsonSerializer.UnboxOnWrite<T>(value)!;

System\Text\Json\Serialization\JsonSerializerOptions.Caching.cs (2)

51/// Returned metadata can be downcast to <see cref="JsonTypeInfo{T}"/> and used with the relevant <see cref="JsonSerializer"/> overloads. 76/// Returned metadata can be downcast to <see cref="JsonTypeInfo{T}"/> and used with the relevant <see cref="JsonSerializer"/> overloads.

System\Text\Json\Serialization\JsonSerializerOptions.Converters.cs (2)

13/// Provides options to be used with <see cref="JsonSerializer"/>. 45if (JsonSerializer.IsReflectionEnabledByDefault)

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

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

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

76get => _typeDiscriminatorPropertyName ?? JsonSerializer.TypePropertyName;

System\Text\Json\Serialization\Metadata\JsonPropertyInfo.cs (5)

211if (!JsonSerializer.IsValidCreationHandlingValue(value.Value)) 471[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 472[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 481Name is JsonSerializer.IdPropertyName or JsonSerializer.RefPropertyName)

System\Text\Json\Serialization\Metadata\JsonPropertyInfoOfT.cs (2)

142[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)] 143[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]

System\Text\Json\Serialization\Metadata\JsonTypeInfo.cs (6)

337/// it has been passed to one of the <see cref="JsonSerializer"/> methods, 507if (value is not null && !JsonSerializer.IsValidNumberHandlingValue(value.Value)) 548if (value is not null && !JsonSerializer.IsValidUnmappedMemberHandlingValue(value.Value)) 592if (value is not null && !JsonSerializer.IsValidCreationHandlingValue(value.Value)) 1003[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 1004[RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)]

System\Text\Json\Serialization\Metadata\JsonTypeInfoOfT.WriteHelpers.cs (8)

70int flushThreshold = (int)(writer.Capacity * JsonSerializer.FlushThreshold); 80int flushThreshold = (int)(4 * PipeOptions.Default.MinimumSegmentSize * JsonSerializer.FlushThreshold); 311state.FlushThreshold = (int)(bufferWriter.Capacity * JsonSerializer.FlushThreshold); 341=> Serialize(writer, JsonSerializer.UnboxOnWrite<T>(rootValue), rootValue); 344=> SerializeAsync(pipeWriter, JsonSerializer.UnboxOnWrite<T>(rootValue), flushThreshold, cancellationToken, rootValue); 347=> SerializeAsync(utf8Json, JsonSerializer.UnboxOnWrite<T>(rootValue), cancellationToken, rootValue); 350=> SerializeAsync(utf8Json, JsonSerializer.UnboxOnWrite<T>(rootValue), cancellationToken, rootValue); 353=> Serialize(utf8Json, JsonSerializer.UnboxOnWrite<T>(rootValue), rootValue);

System\Text\Json\Serialization\Metadata\PolymorphicTypeResolver.cs (2)

81if (!propertyName.Equals(JsonSerializer.TypePropertyName, StringComparison.Ordinal)) 86if ((JsonSerializer.GetMetadataPropertyName(utf8EncodedName, resolver: null) & ~MetadataPropertyName.Type) != 0)

System\Text\Json\Serialization\Metadata\ReflectionEmitCachingMemberAccessor.cs (2)

16[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 17[RequiresUnreferencedCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]

System\Text\Json\Serialization\Metadata\ReflectionEmitMemberAccessor.cs (2)

13[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 14[RequiresUnreferencedCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]

System\Text\Json\Serialization\Metadata\ReflectionMemberAccessor.cs (2)

11[RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] 12[RequiresUnreferencedCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]

System\Text\Json\Serialization\ReferenceHandler.cs (1)

9/// This class defines how the <see cref="JsonSerializer"/> deals with references on serialization and deserialization.

System\Text\Json\Serialization\ReferenceHandlerOfT.cs (1)

7/// This class defines how the <see cref="JsonSerializer"/> deals with references on serialization and deserialization.

System\Text\Json\Serialization\ReferenceResolver.cs (1)

7/// This class defines how the <see cref="JsonSerializer"/> deals with references on serialization and deserialization.

System\Text\Json\ThrowHelper.Serialization.cs (1)

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

System.Windows.Forms.Tests (9)

System\Windows\Forms\BinaryFormat\WinFormsBinaryFormattedObjectTests.cs (3)

43JsonBytes = JsonSerializer.SerializeToUtf8Bytes(testData) 70JsonBytes = JsonSerializer.SerializeToUtf8Bytes(testData) 98result = JsonSerializer.Deserialize<SimpleTestData>(JsonBytes);

System\Windows\Forms\ClipboardTests.cs (6)

966JsonSerializer.Deserialize(byteData.GetArray(), typeof(SimpleTestData)).Should().BeEquivalentTo(testData); 978byte[] serialized = JsonSerializer.SerializeToUtf8Bytes(font); 979Action a1 = () => JsonSerializer.Deserialize<Font>(serialized); 1015JsonSerializer.Deserialize(jsonBytes, typeof(SimpleTestData)).Should().BeEquivalentTo(data); 1043return JsonSerializer.Deserialize<T>(_formatToJson[format]); 1058_formatToJson.Add(format, JsonSerializer.SerializeToUtf8Bytes(data));

Templates.Blazor.Tests (2)

BlazorWasmTemplateTest.cs (1)

122var serviceWorkerAssetsManifestVersion = JsonSerializer.Deserialize<string>(serviceWorkerAssetsManifestVersionJson);