UTF8

Caching\DiskCache.cs (1)

159var bytes = Encoding.UTF8.GetBytes(key);

Commands\McpCallCommand.cs (1)

138_interactionService.DisplayRawText(System.Text.Encoding.UTF8.GetString(stream.ToArray()));

Commands\McpToolsCommand.cs (1)

102_interactionService.DisplayRawText(System.Text.Encoding.UTF8.GetString(stream.ToArray()));

Diagnostics\FileLoggerProvider.cs (1)

77_writer = new StreamWriter(logFilePath, append: false, Encoding.UTF8)

NuGet\BundleNuGetService.cs (1)

201var hashBytes = System.Security.Cryptography.SHA256.HashData(System.Text.Encoding.UTF8.GetBytes(content));

Packaging\TemporaryNuGetConfig.cs (1)

54Encoding = System.Text.Encoding.UTF8,

Program.cs (1)

660Console.OutputEncoding = Encoding.UTF8;

Projects\AppHostServerProject.cs (1)

45var pathHash = SHA256.HashData(Encoding.UTF8.GetBytes(normalizedPath));

Projects\DotNetBasedAppHostServerProject.cs (1)

68var pathHash = SHA256.HashData(Encoding.UTF8.GetBytes(_appPath));

Projects\GuestAppHostProject.cs (1)

1264var bytes = System.Security.Cryptography.SHA256.HashData(System.Text.Encoding.UTF8.GetBytes(sb.ToString()));

Projects\PrebuiltAppHostServer.cs (1)

75var pathHash = SHA256.HashData(Encoding.UTF8.GetBytes(_appPath));

src\Shared\BackchannelConstants.cs (1)

106var hashBytes = SHA256.HashData(Encoding.UTF8.GetBytes(appHostPath));

src\Shared\UserSecrets\UserSecretsPathHelper.cs (1)

63Encoding.UTF8.GetBytes(appHostPath.ToLowerInvariant()));

Telemetry\MachineInformationProviderBase.cs (1)

82var hashInput = s_sHA256.ComputeHash(Encoding.UTF8.GetBytes(value));

Telemetry\UnixMachineInformationProvider.cs (2)

86await File.WriteAllTextAsync(fullPath, value, Encoding.UTF8); 113var contents = await File.ReadAllTextAsync(path, Encoding.UTF8);

Utils\ConfigurationHelper.cs (1)

120var bytes = System.Text.Encoding.UTF8.GetBytes(cleanJson);

AspireEventHubsExtensionsTests.cs (1)

624var buffer = Encoding.UTF8.GetBytes(content);

tests\Aspire.Azure.Security.KeyVault.Tests\MockTransport.cs (1)

163SetContent(Encoding.UTF8.GetBytes(content));

AspireKeyVaultExtensionsTests.cs (1)

150var buffer = Encoding.UTF8.GetBytes(content);

MockTransport.cs (1)

163SetContent(Encoding.UTF8.GetBytes(content));

Agents\SigstoreNpmProvenanceCheckerTests.cs (1)

999var payloadBase64 = Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(payload));

Caching\DiskCacheTests.cs (1)

139var bytes = System.Text.Encoding.UTF8.GetBytes(key);

Commands\ExportCommandTests.cs (5)

248Content = new StringContent(resourcesJson, System.Text.Encoding.UTF8, "application/json") 255Content = new StringContent(BuildLogsJson(), System.Text.Encoding.UTF8, "application/json") 262Content = new StringContent(BuildTracesJson(), System.Text.Encoding.UTF8, "application/json") 725Content = new StringContent(resourcesJson, System.Text.Encoding.UTF8, "application/json") 735Content = new StringContent(json, System.Text.Encoding.UTF8, "application/json")

Commands\TelemetryTestHelper.cs (2)

96Content = new StringContent(resourcesJson, System.Text.Encoding.UTF8, "application/json") 106Content = new StringContent(json, System.Text.Encoding.UTF8, "application/json")

Mcp\ListStructuredLogsToolTests.cs (6)

160Content = new StringContent(resourcesResponse, System.Text.Encoding.UTF8, "application/json") 167Content = new StringContent(apiResponse, System.Text.Encoding.UTF8, "application/json") 263Content = new StringContent(resourcesResponse, System.Text.Encoding.UTF8, "application/json") 270Content = new StringContent(apiResponse, System.Text.Encoding.UTF8, "application/json") 318Content = new StringContent(resourcesResponse, System.Text.Encoding.UTF8, "application/json") 325Content = new StringContent(emptyLogsJson, System.Text.Encoding.UTF8, "application/json")

Mcp\ListTracesToolTests.cs (8)

Utils\CliTestHelper.cs (1)

629public override Encoding Encoding => Encoding.UTF8;

src\Vendoring\OpenTelemetry.Instrumentation.ConfluentKafka\InstrumentedProducer.cs (1)

368message.Headers.Add(key, Encoding.UTF8.GetBytes(value));

src\Vendoring\OpenTelemetry.Instrumentation.ConfluentKafka\OpenTelemetryConsumeResultExtensions.cs (1)

181yield return Encoding.UTF8.GetString(bytes);

ConsumerConfigurationTests.cs (1)

222static Stream CreateStreamFromString(string data) => new MemoryStream(Encoding.UTF8.GetBytes(data));

ProducerConfigurationTests.cs (1)

212static Stream CreateStreamFromString(string data) => new MemoryStream(Encoding.UTF8.GetBytes(data));

Configuration\DashboardOptions.cs (8)

Extensions\JSInteropExtensions.cs (1)

34return js.DownloadFileAsync(fileName, Encoding.UTF8.GetBytes(content));

Model\GenAI\GenAIMessageParsingHelper.cs (1)

19var bytes = Encoding.UTF8.GetBytes(json);

Model\TextVisualizerViewModel.cs (2)

118var jsonData = Encoding.UTF8.GetBytes(jsonString); 183var formattedJson = Encoding.UTF8.GetString(stream.ToArray());

Otlp\Http\OtlpHttpEndpointsBuilder.cs (4)

117await httpContext.Response.WriteAsync(json, Encoding.UTF8).ConfigureAwait(false); 193return Encoding.UTF8.GetString(data.FirstSpan); 198return Encoding.UTF8.GetString(bytes); 234await httpContext.Response.WriteAsync(jsonResponse, Encoding.UTF8).ConfigureAwait(false);

src\Shared\CompareHelpers.cs (2)

18var requestByteCount = Encoding.UTF8.GetByteCount(requestKey); 29var encodedByteCount = Encoding.UTF8.GetBytes(requestKey, requestBytesSpan);

Pages\TraceDetailsTests.cs (9)

70var traceId = Convert.ToHexString(Encoding.UTF8.GetBytes("1")); 125var traceId = Convert.ToHexString(Encoding.UTF8.GetBytes("1")); 141traceId = Convert.ToHexString(Encoding.UTF8.GetBytes("2")); 193var traceId = Convert.ToHexString(Encoding.UTF8.GetBytes("1")); 275var traceId = Convert.ToHexString(Encoding.UTF8.GetBytes("1")); 369var traceId = Convert.ToHexString(Encoding.UTF8.GetBytes("1")); 426var traceId = Convert.ToHexString(Encoding.UTF8.GetBytes("1")); 509var traceId = Convert.ToHexString(Encoding.UTF8.GetBytes("1")); 584var traceId = Convert.ToHexString(Encoding.UTF8.GetBytes("1"));

tests\Shared\Telemetry\TelemetryTestHelpers.cs (7)

37var resolved = Encoding.UTF8.GetString(bytes); 43var id = Encoding.UTF8.GetBytes(text); 160TraceId = ByteString.CopyFrom(Encoding.UTF8.GetBytes(traceId)), 161SpanId = ByteString.CopyFrom(Encoding.UTF8.GetBytes(spanId)), 162ParentSpanId = parentSpanId is null ? ByteString.Empty : ByteString.CopyFrom(Encoding.UTF8.GetBytes(parentSpanId)), 196TraceId = (traceId != null) ? ByteString.CopyFrom(Encoding.UTF8.GetBytes(traceId)) : ByteString.CopyFrom(Convert.FromHexString("5465737454726163654964")), 197SpanId = (spanId != null) ? ByteString.CopyFrom(Encoding.UTF8.GetBytes(spanId)) : ByteString.CopyFrom(Convert.FromHexString("546573745370616e4964")),

Integration\McpServiceTests.cs (3)

326var content = new ByteArrayContent(Encoding.UTF8.GetBytes(json)); 360var notificationContent = new ByteArrayContent(Encoding.UTF8.GetBytes(notificationJson)); 387var content = new ByteArrayContent(Encoding.UTF8.GetBytes(json));

Integration\OtlpHttpJsonTests.cs (8)

Integration\OtlpHttpServiceTests.cs (2)

233using var content = new ByteArrayContent(Encoding.UTF8.GetBytes("{}")); 264using var content = new ByteArrayContent(Encoding.UTF8.GetBytes("{}"));

Model\TelemetryImportServiceTests.cs (11)

TelemetryRepositoryTests\MetricsTests.cs (2)

415SpanId = ByteString.CopyFrom(Encoding.UTF8.GetBytes("span-id")), 416TraceId = ByteString.CopyFrom(Encoding.UTF8.GetBytes("trace-id"))

TelemetryRepositoryTests\TraceTests.cs (8)

tests\Shared\Telemetry\TelemetryTestHelpers.cs (7)

37var resolved = Encoding.UTF8.GetString(bytes); 43var id = Encoding.UTF8.GetBytes(text); 160TraceId = ByteString.CopyFrom(Encoding.UTF8.GetBytes(traceId)), 161SpanId = ByteString.CopyFrom(Encoding.UTF8.GetBytes(spanId)), 162ParentSpanId = parentSpanId is null ? ByteString.Empty : ByteString.CopyFrom(Encoding.UTF8.GetBytes(parentSpanId)), 196TraceId = (traceId != null) ? ByteString.CopyFrom(Encoding.UTF8.GetBytes(traceId)) : ByteString.CopyFrom(Convert.FromHexString("5465737454726163654964")), 197SpanId = (spanId != null) ? ByteString.CopyFrom(Encoding.UTF8.GetBytes(spanId)) : ByteString.CopyFrom(Convert.FromHexString("546573745370616e4964")),

ApplicationModel\ReferenceExpression.cs (4)

285xxHash.Append(Encoding.UTF8.GetBytes(conditionExpr)); 286xxHash.Append(Encoding.UTF8.GetBytes(whenTrue.ValueExpression)); 287xxHash.Append(Encoding.UTF8.GetBytes(whenFalse.ValueExpression)); 288xxHash.Append(Encoding.UTF8.GetBytes(matchValue));

Dashboard\ResourceServiceOptions.cs (1)

32_apiKeyBytes = value is null ? null : Encoding.UTF8.GetBytes(value);

Dcp\DcpExecutor.cs (1)

2831lookup = Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(lookup)));

Dcp\DcpHost.cs (2)

363return (_logger, LogLevel.Debug, Encoding.UTF8.GetString(line)); 367hash.AddBytes(Encoding.UTF8.GetBytes(category));

Dcp\DcpKubernetesClient.cs (1)

130httpRequest.Content = new StringContent(content, System.Text.Encoding.UTF8);

Dcp\DcpLogParser.cs (3)

93message = Encoding.UTF8.GetString(messageSpan); 94category = Encoding.UTF8.GetString(categorySpan); 113var bytes = Encoding.UTF8.GetBytes(line);

DistributedApplicationBuilder.cs (2)

272var appHostPathShaBytes = SHA256.HashData(Encoding.UTF8.GetBytes(AppHostPath.ToLowerInvariant())); 276var appHostProjectNameShaBytes = SHA256.HashData(Encoding.UTF8.GetBytes(appHostName));

src\Shared\BackchannelConstants.cs (1)

106var hashBytes = SHA256.HashData(Encoding.UTF8.GetBytes(appHostPath));

src\Shared\CompareHelpers.cs (2)

18var requestByteCount = Encoding.UTF8.GetByteCount(requestKey); 29var encodedByteCount = Encoding.UTF8.GetBytes(requestKey, requestBytesSpan);

src\Shared\UserSecrets\UserSecretsPathHelper.cs (1)

63Encoding.UTF8.GetBytes(appHostPath.ToLowerInvariant()));

UserSecrets\UserSecretsManagerFactory.cs (3)

150await File.WriteAllTextAsync(FilePath, json, Encoding.UTF8, cancellationToken).ConfigureAwait(false); 192File.WriteAllText(tempFilename, json, Encoding.UTF8); 197File.WriteAllText(FilePath, json, Encoding.UTF8);

Utils\ImageNameGenerator.cs (1)

25var bytes = Encoding.UTF8.GetBytes($"{builder.ApplicationBuilder.AppHostDirectory}{DateTime.UtcNow.Ticks}");

AzureBicepResource.cs (1)

206using var reader = new StreamReader(resourceStream, Encoding.UTF8);

Provisioning\BicepUtilities.cs (1)

96var hashedContents = Crc32.Hash(Encoding.UTF8.GetBytes(input));

AzureEventHubsExtensions.cs (2)

351Contents = Encoding.UTF8.GetString(writeStream.ToArray()), 485return Encoding.UTF8.GetString(stream.ToArray());

AzureServiceBusExtensions.cs (2)

499Contents = Encoding.UTF8.GetString(writeStream.ToArray()), 639return Encoding.UTF8.GetString(stream.ToArray());

AzureDeployerTests.cs (1)

1358ContentStream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(content));

AzureEventHubsExtensionsTests.cs (2)

101await producerClient.SendAsync([new EventData(Encoding.UTF8.GetBytes("hello worlds"))]); 105Assert.Equal("hello worlds", Encoding.UTF8.GetString(partitionEvent.Data.EventBody.ToArray()));

DefaultUserPrincipalProviderTests.cs (9)

ProvisioningTestHelpers.cs (3)

149var headerBase64 = Convert.ToBase64String(Encoding.UTF8.GetBytes(headerJson)) 163var payloadBase64 = Convert.ToBase64String(Encoding.UTF8.GetBytes(payloadJson)) 168var signatureBase64 = Convert.ToBase64String(Encoding.UTF8.GetBytes("test-signature"))

DevTunnelCli.cs (2)

372psi.StandardOutputEncoding = Encoding.UTF8; 373psi.StandardErrorEncoding = Encoding.UTF8;

HostedAgent\HostedAgentBuilderExtension.cs (1)

175request.Content = new StringContent(new JsonObject() { ["input"] = input }.ToString(), System.Text.Encoding.UTF8, "application/json");

GitHubModelsHealthCheck.cs (1)

53request.Content = new StringContent(jsonPayload, System.Text.Encoding.UTF8, "application/json");

Yaml\ByteArrayStringYamlConverter.cs (2)

24return string.IsNullOrEmpty(scalar.Value) ? null : Encoding.UTF8.GetBytes(scalar.Value); 43emitter.Emit(new Scalar(Encoding.UTF8.GetString(obj)));

Utilities\MauiEnvironmentHelper.cs (2)

82await File.WriteAllTextAsync(targetsFilePath, targetsContent, Encoding.UTF8, cancellationToken).ConfigureAwait(false); 253await File.WriteAllTextAsync(targetsFilePath, targetsContent, Encoding.UTF8, cancellationToken).ConfigureAwait(false);

PostgresBuilderExtensions.cs (1)

664return Encoding.UTF8.GetString(stream.ToArray());

RabbitMQFunctionalTests.cs (4)

84var body = Encoding.UTF8.GetBytes(message); 89Assert.Equal(message, Encoding.UTF8.GetString(result!.Body.Span)); 149var body = Encoding.UTF8.GetBytes(message); 206Assert.Equal("Hello World!", Encoding.UTF8.GetString(result!.Body.Span));

SeqFunctionalTests.cs (1)

53var content = new StringContent(payload, Encoding.UTF8, "application/json");

ApplicationModel\Docker\DockerfileBuilderEdgeCasesTests.cs (6)

46var content = Encoding.UTF8.GetString(stream.ToArray()); 78var content = Encoding.UTF8.GetString(stream.ToArray()); 103var content = Encoding.UTF8.GetString(stream.ToArray()); 132var content = Encoding.UTF8.GetString(stream.ToArray()); 189var content = Encoding.UTF8.GetString(stream.ToArray()); 231var content = Encoding.UTF8.GetString(stream.ToArray());

ApplicationModel\Docker\DockerfileBuilderIntegrationTests.cs (2)

41var content = Encoding.UTF8.GetString(stream.ToArray()); 116var content = Encoding.UTF8.GetString(stream.ToArray());

ApplicationModel\Docker\DockerfileBuilderTests.cs (2)

131var content = Encoding.UTF8.GetString(stream.ToArray()); 170var content = Encoding.UTF8.GetString(stream.ToArray());

ApplicationModel\Docker\DockerfileStageTests.cs (7)

327var content = Encoding.UTF8.GetString(stream.ToArray()); 361var content = Encoding.UTF8.GetString(stream.ToArray()); 397var content = Encoding.UTF8.GetString(stream.ToArray()); 428var content = Encoding.UTF8.GetString(stream.ToArray()); 470var content = Encoding.UTF8.GetString(stream.ToArray()); 528var content = Encoding.UTF8.GetString(stream.ToArray()); 563var content = Encoding.UTF8.GetString(stream.ToArray());

ApplicationModel\Docker\DockerfileStatementsTests.cs (16)

AspireStoreTests.cs (2)

65var content = new MemoryStream(System.Text.Encoding.UTF8.GetBytes("Test content")); 108var content = new MemoryStream(System.Text.Encoding.UTF8.GetBytes("Test content"));

Dcp\DcpExecutorTests.cs (7)

651await pipes.StandardOut.Writer.WriteAsync(Encoding.UTF8.GetBytes("2024-08-19T06:10:33.473275911Z Hello world" + Environment.NewLine)); 662await pipes.StandardErr.Writer.WriteAsync(Encoding.UTF8.GetBytes("2024-08-19T06:10:32.661Z Next" + Environment.NewLine)); 706return new MemoryStream(Encoding.UTF8.GetBytes("2024-08-19T06:10:01.000Z First" + Environment.NewLine)); 708return new MemoryStream(Encoding.UTF8.GetBytes("2024-08-19T06:10:02.000Z Second" + Environment.NewLine)); 710return new MemoryStream(Encoding.UTF8.GetBytes("2024-08-19T06:10:03.000Z Third" + Environment.NewLine)); 712return new MemoryStream(Encoding.UTF8.GetBytes( 797return new MemoryStream(Encoding.UTF8.GetBytes(systemLogs));

Dcp\DcpLogParserTests.cs (11)

Dcp\TestKubernetesService.cs (1)

34_startStream = startStream ?? ((obj, logStreamType) => new MemoryStream(Encoding.UTF8.GetBytes($"Logs for {obj.Metadata.Name} ({logStreamType})")));

ProjectResourceTests.cs (1)

968.AddJsonStream(new MemoryStream(Encoding.UTF8.GetBytes(JsonConfigString)))

UserSecretsParameterDefaultTests.cs (1)

80File.WriteAllText(userSecretsPath, secretsFileContents, Encoding.UTF8);

Utils\VolumeNameGeneratorTests.cs (1)

130var expectedShaBytes = SHA256.HashData(Encoding.UTF8.GetBytes(builder.AppHostPath.ToLowerInvariant()));

AspireAppConfigurationExtensionsTest.cs (1)

118var buffer = Encoding.UTF8.GetBytes(content);

tests\Aspire.Azure.Security.KeyVault.Tests\MockTransport.cs (1)

163SetContent(Encoding.UTF8.GetBytes(content));

AspireRabbitMQExtensionsTests.cs (1)

116static Stream CreateStreamFromString(string data) => new MemoryStream(Encoding.UTF8.GetBytes(data));

tests\Aspire.RabbitMQ.Client.Tests\AspireRabbitMQExtensionsTests.cs (1)

116static Stream CreateStreamFromString(string data) => new MemoryStream(Encoding.UTF8.GetBytes(data));

Program.cs (2)

31var data = Convert.ToBase64String(Encoding.UTF8.GetBytes("Hello, World!")); 57var data = new BinaryData(Encoding.UTF8.GetBytes(RandomString(length)));

MtomBindingTestHelper.cs (1)

68var mtomElement = new MtomMessageEncodingBindingElement(MessageVersion.Soap11, Encoding.UTF8);

ObjectFileScraper.cs (1)

346return System.Text.Encoding.UTF8.GetString(nameBytes);

TypedProxyTests.4.0.0.cs (3)

231new TextMessageEncodingBindingElement(MessageVersion.Default, Encoding.UTF8), 295new TextMessageEncodingBindingElement(MessageVersion.Default, Encoding.UTF8), 359new TextMessageEncodingBindingElement(MessageVersion.Default, Encoding.UTF8),

GeneratorTests.cs (1)

159var bytes = Encoding.UTF8.GetBytes($"<summary>{input}</summary>");

ServiceContractTests.4.0.0.cs (2)

499var reader = new StreamReader(stream, Encoding.UTF8); 506var sw = new StreamWriter(ms, Encoding.UTF8);

src\roslyn\src\Compilers\Shared\BuildServerConnection.cs (1)

703var bytes = sha.ComputeHash(Encoding.UTF8.GetBytes(pipeNameInput));

src\roslyn\src\Compilers\Shared\CompilerServerLogger.cs (1)

155byte[] bytes = Encoding.UTF8.GetBytes(output);

Program.cs (2)

106using var outFile = new StreamWriter(File.Open(outputMainFile, FileMode.Create), Encoding.UTF8); 177using var outFile = new StreamWriter(File.Open(outputFile, FileMode.Create), Encoding.UTF8);

BuildServer\RazorPidFile.cs (1)

34using (var reader = new StreamReader(stream, Encoding.UTF8))

Commands\Project\Convert\ProjectConvertCommand.cs (1)

188using var writer = new StreamWriter(stream, Encoding.UTF8);

Commands\Run\VirtualProjectBuildingCommand.cs (1)

628stream.Write(Encoding.UTF8.GetBytes(Environment.NewLine));

Commands\Test\MTP\IPC\HttpTestHostGateway.cs (2)

237byte[] providedToken = Encoding.UTF8.GetBytes(header.Parameter); 238byte[] expectedToken = Encoding.UTF8.GetBytes(Token);

Commands\Test\MTP\IPC\Serializers\BaseSerializer.cs (7)

19return Encoding.UTF8.GetString(bytes, 0, stringLen); 33return Encoding.UTF8.GetString(bytes, 0, size); 43int stringutf8TotalBytes = Encoding.UTF8.GetByteCount(str); 51Encoding.UTF8.GetBytes(str, bytes); 62int stringutf8TotalBytes = Encoding.UTF8.GetByteCount(str); 66Encoding.UTF8.GetBytes(str, bytes); 77int stringutf8TotalBytes = Encoding.UTF8.GetByteCount(str);

Commands\Test\MTP\Terminal\TerminalTestReporter.cs (1)

1501terminal.Append(Encoding.UTF8.GetString(buffer.GetBuffer(), 0, (int)buffer.Length));

Commands\Test\MTP\TestResultsDirectoryResolver.cs (1)

305byte[] hash = SHA256.HashData(Encoding.UTF8.GetBytes(value));

Program.cs (1)

88Console.OutputEncoding = Encoding.UTF8;

src\sdk\artifacts\.packages\microsoft.codeanalysis.buildclient\5.11.0-1.26422.113\contentFiles\cs\net11.0\BuildServerConnection.cs (1)

703var bytes = sha.ComputeHash(Encoding.UTF8.GetBytes(pipeNameInput));

src\sdk\artifacts\.packages\microsoft.codeanalysis.buildclient\5.11.0-1.26422.113\contentFiles\cs\net11.0\CompilerServerLogger.cs (1)

155byte[] bytes = Encoding.UTF8.GetBytes(output);

ToolManifest\ToolManifestEditor.cs (1)

398return Encoding.UTF8.GetString(arrayBufferWriter.WrittenMemory.ToArray());

src\sdk\src\Cli\dotnet\ToolManifest\ToolManifestEditor.cs (1)

398return Encoding.UTF8.GetString(arrayBufferWriter.WrittenMemory.ToArray());

Commands\FormatCommandCommon.cs (1)

263Console.InputEncoding = Encoding.UTF8;

Formatters\CharsetFormatter.cs (1)

88"utf-8-bom" => Encoding.UTF8,// UTF-8 with BOM Marker

src\aspnetcore\src\Tools\GetDocumentInsider\src\ProgramBase.cs (1)

28Console.OutputEncoding = Encoding.UTF8;

Sgen.cs (1)

562byte[] valueBytes = Encoding.UTF8.GetBytes(value);

Program.cs (1)

189return new MemoryStream(Encoding.UTF8.GetBytes(processedContent));

FileSuggestionRegistration.cs (2)

51using (var sr = new StreamReader(_registrationConfigurationFilePath, Encoding.UTF8)) 77using (var sr = new StreamReader(_registrationConfigurationFilePath, Encoding.UTF8))

CodeDomFixup\MethodCreationHelper.cs (1)

1619if (encoding.WebName == Encoding.UTF8.WebName)

FrameworkFork\Microsoft.CodeDom\Compiler\CodeCompiler.cs (3)

272using (StreamWriter sw = new StreamWriter(temp, Encoding.UTF8)) 344using (StreamWriter sw = new StreamWriter(temp, Encoding.UTF8)) 384using (StreamWriter sw = new StreamWriter(temp, Encoding.UTF8))

FrameworkFork\Microsoft.CodeDom\Microsoft\CSharpCodeProvider.cs (4)

713using (StreamWriter sw = new StreamWriter(temp, Encoding.UTF8)) 3928string[] lines = ReadAllLines(outputFile, Encoding.UTF8, FileShare.ReadWrite); 4180using (StreamWriter sw = new StreamWriter(temp, Encoding.UTF8)) 4241using (StreamWriter sw = new StreamWriter(temp, Encoding.UTF8))

FrameworkFork\Microsoft.CodeDom\Microsoft\VBCodeProvider.cs (1)

3279string fileStr = Encoding.UTF8.GetString(fileBytes);

FrameworkFork\Microsoft.Xml\Xml\Core\XmlTextReaderImpl.cs (1)

3252_ps.encoding = Encoding.UTF8;

FrameworkFork\Microsoft.Xml\Xml\Core\XmlWriterSettings.cs (2)

502Debug.Assert(Encoding.UTF8.WebName == "utf-8"); 688_encoding = Encoding.UTF8;

FrameworkFork\System.Runtime.Serialization\System\Runtime\Serialization\DataContract.cs (1)

1862byte[] namespaceBytes = Encoding.UTF8.GetBytes(namespaces);

FrameworkFork\System.Runtime.Serialization\System\Runtime\Serialization\ExceptionDataContract.cs (1)

589byte[] byteBuffer = Encoding.UTF8.GetBytes(result);

FrameworkFork\System.Runtime.Serialization\System\Runtime\Serialization\XmlObjectSerializer.cs (1)

26XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(stream, Encoding.UTF8, false /*ownsStream*/);

FrameworkFork\System.Runtime.Serialization\System\Xml\EncodingStreamWrapper.cs (1)

640_byteCount = Encoding.UTF8.GetBytes(_chars, 0, charCount, _bytes, 0);

FrameworkFork\System.Runtime.Serialization\System\Xml\XmlDictionaryString.cs (1)

80_buffer = System.Text.Encoding.UTF8.GetBytes(_value);

FrameworkFork\System.Runtime.Serialization\System\Xml\XmlNodeWriter.cs (8)

FrameworkFork\System.Runtime.Serialization\System\Xml\XmlUTF8TextReader.cs (2)

666XmlExceptionHelper.ThrowTokenExpected(this, "?>", Encoding.UTF8.GetString(buffer, offset, 2)); 1077XmlExceptionHelper.ThrowTokenExpected(this, "[CDATA[", Encoding.UTF8.GetString(buffer, offset, 7));

FrameworkFork\System.Runtime.Serialization\System\Xml\XmlUTF8TextWriter.cs (2)

29if (encoding.WebName != Encoding.UTF8.WebName) 106if (encoding != null && encoding == Encoding.UTF8)

FrameworkFork\System.ServiceModel\Internals\System\Runtime\UrlUtility.cs (4)

31return ParseQueryString(query, Encoding.UTF8); 60return UrlEncode(str, Encoding.UTF8); 79return UrlEncodeSpaces(UrlEncodeNonAscii(str, Encoding.UTF8)); 148e = Encoding.UTF8;

FrameworkFork\System.ServiceModel\System\IdentityModel\CanonicalFormWriter.cs (1)

15internal static readonly Encoding Utf8WithoutPreamble = Encoding.UTF8;

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\BinaryMessageEncoder.cs (5)

391int utf8ValueSize = Encoding.UTF8.GetByteCount(newStrings[i].Value); 422int utf8ValueSize = Encoding.UTF8.GetByteCount(newString); 424offset += Encoding.UTF8.GetBytes(newString, 0, newString.Length, buffer, offset); 496string value = Encoding.UTF8.GetString(buffer, offset, utf8ValueSize); 905int bytesRequired = Encoding.UTF8.GetByteCount(s.Value);

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\FramingDecoders.cs (1)

159_value = Encoding.UTF8.GetString(_encodedBytes, 0, _encodedSize);

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\FramingEncoders.cs (2)

56int valueByteCount = Encoding.UTF8.GetByteCount(value); 62Encoding.UTF8.GetBytes(value, 0, value.Length, _encodedBytes, offset);

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\HttpChannelHelpers.cs (1)

171return Encoding.UTF8.GetString(responseBuffer, 0, bytesToRead);

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\TransportDefaults.cs (2)

58public static readonly Encoding[] SupportedEncodings = new Encoding[] { Encoding.UTF8, Encoding.Unicode, Encoding.BigEndianUnicode }; 63new CharSetEncoding("utf-8", Encoding.UTF8),

FrameworkFork\System.ServiceModel\System\ServiceModel\Security\WSSecurityPolicy.cs (2)

2292writer = new XmlTextWriter(stream, System.Text.Encoding.UTF8); 2307writer = new XmlTextWriter(stream, System.Text.Encoding.UTF8);

FrameworkFork\System.ServiceModel\System\ServiceModel\Security\WSTrust.cs (1)

807using (XmlDictionaryWriter writer = XmlDictionaryWriter.CreateDictionaryWriter(new XmlTextWriter(stream, Encoding.UTF8)))

Metadata\ServiceDescriptor.cs (2)

119Encoding encoding = Encoding.UTF8; 124Encoding.UTF8,

Shared\Utilities\ProcessRunner.cs (2)

88proc.StartInfo.StandardErrorEncoding = Encoding.UTF8; 89proc.StartInfo.StandardOutputEncoding = Encoding.UTF8;

Tool.cs (2)

429Console.InputEncoding = Encoding.UTF8; 430Console.OutputEncoding = Encoding.UTF8;

Microsoft\Tools\ServiceModel\SvcUtil\Tool.cs (1)

99if ((System.Console.OutputEncoding.CodePage != Encoding.UTF8.CodePage) &&

Internal\SecretsStore.cs (1)

83File.WriteAllText(_secretsFilePath, contents, Encoding.UTF8);

FileSetSerializer.cs (1)

74using var writer = JsonReaderWriterFactory.CreateJsonWriter(fileStream, Encoding.UTF8, ownsStream: false, indent: true);

MessageVersionTests.4.0.0.cs (2)

30binding = new CustomBinding(new TextMessageEncodingBindingElement(MessageVersion.Soap12WSAddressing10, Encoding.UTF8), new HttpTransportBindingElement()); 66binding = new CustomBinding(new TextMessageEncodingBindingElement(MessageVersion.Soap11, Encoding.UTF8), new HttpTransportBindingElement());

MessageVersionTests.cs (5)

30binding = new CustomBinding(new TextMessageEncodingBindingElement(MessageVersion.Soap12WSAddressingAugust2004, Encoding.UTF8), new HttpTransportBindingElement()); 66binding = new CustomBinding(new TextMessageEncodingBindingElement(MessageVersion.Soap11WSAddressingAugust2004, Encoding.UTF8), new HttpTransportBindingElement()); 102binding = new CustomBinding(new TextMessageEncodingBindingElement(MessageVersion.CreateVersion(EnvelopeVersion.Soap12, AddressingVersion.None), Encoding.UTF8), new HttpTransportBindingElement()); 138binding = new CustomBinding(new TextMessageEncodingBindingElement(MessageVersion.CreateVersion(EnvelopeVersion.Soap11, AddressingVersion.WSAddressing10), Encoding.UTF8), new HttpTransportBindingElement()); 174binding = new CustomBinding(new TextMessageEncodingBindingElement(MessageVersion.CreateVersion(EnvelopeVersion.Soap11, AddressingVersion.WSAddressing10), Encoding.UTF8), new TcpTransportBindingElement());

EventSourceGenerator.Emitter.cs (3)

33context.AddSource($"{ec.ClassName}.g.cs", SourceText.From(sb.ToString(), Encoding.UTF8)); 90int metadataSize = Encoding.UTF8.GetByteCount(name) + 3; 95Encoding.UTF8.GetBytes(name, 0, name.Length, metadata, 2);

TextTests.4.1.0.cs (2)

29CustomBinding binding = new CustomBinding(new CustomTextMessageBindingElement(Encoding.UTF8.WebName), 72CustomBinding binding = new CustomBinding(new CustomTextMessageBindingElement(Encoding.UTF8.WebName),

Program.cs (1)

641textWriter = new StreamWriter(fileWithPath, false, Encoding.UTF8);

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\StringTable.cs (1)

413text = Encoding.UTF8.GetString(bytes, utf8Bytes.Length);

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\SourceTextExtensions.cs (1)

38using (var writer = new StreamWriter(stream, Encoding.UTF8, 1024, true))

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\StringExtensions.cs (1)

15return Encoding.UTF8.GetByteCount(value) == value.Length;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectReader.cs (1)

47_reader = new BinaryReader(stream, Encoding.UTF8, leaveOpen);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectWriter.cs (1)

94_writer = new BinaryWriter(stream, Encoding.UTF8, leaveOpen);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\TextEncodingKind.cs (3)

45TextEncodingKind.EncodingUtf8_BOM => Encoding.UTF8, 82Debug.Assert(HasPreamble(Encoding.UTF8)); 83kind = (encoding.Equals(Encoding.UTF8) || HasPreamble(encoding)) ? TextEncodingKind.EncodingUtf8_BOM : TextEncodingKind.EncodingUtf8;

ProgramBase.cs (1)

28Console.OutputEncoding = Encoding.UTF8;

GrammarVisitor.cs (3)

2576return Encoding.UTF8.GetString(bytes.Slice(bytesRead, length)); 3122int byteCount = Encoding.UTF8.GetByteCount(str); 3130Encoding.UTF8.GetBytes(str, utf8Bytes);

Program.cs (1)

803MethodDesc method = owningType.GetMethod(Encoding.UTF8.GetBytes(singleMethodName), null);

src\runtime\src\coreclr\tools\Common\TypeSystem\IL\HelperExtensions.cs (6)

79throw new InvalidOperationException(string.Format("Expected method '{0}' not found on type '{1}'", System.Text.Encoding.UTF8.GetString(name), type)); 94throw new InvalidOperationException(string.Format("Expected field '{0}' not found on type '{1}'", System.Text.Encoding.UTF8.GetString(name), type)); 109throw new InvalidOperationException(string.Format("Expected type '{0}' not found on type '{1}'", Encoding.UTF8.GetString(name), type)); 126@namespace.Length > 0 ? string.Concat(Encoding.UTF8.GetString(@namespace), ".", Encoding.UTF8.GetString(name)) : Encoding.UTF8.GetString(name),

Compiler\CompilerTypeSystemContext.InterfaceThunks.cs (1)

185_prefix = System.Text.Encoding.UTF8.GetBytes(prefixString);

Compiler\Dataflow\AttributeDataFlow.cs (1)

72FieldDesc field = attributeType.GetField(System.Text.Encoding.UTF8.GetBytes(namedArgument.Name!));

Compiler\DependencyAnalysis\CustomAttributeBasedDependencyAlgorithm.cs (1)

195FieldDesc field = attributeType.GetField(System.Text.Encoding.UTF8.GetBytes(fieldName));

Compiler\DependencyAnalysis\NodeFactory.cs (5)

1350var type = _context.SystemModule.GetKnownType(Encoding.UTF8.GetBytes(entry[0]), Encoding.UTF8.GetBytes(entry[1])); 1351var method = type.GetKnownMethod(Encoding.UTF8.GetBytes(entry[2]), null); 1572int stringBytesCount = Encoding.UTF8.GetByteCount(str); 1574Encoding.UTF8.GetBytes(str, 0, str.Length, stringBytes, 0);

Compiler\DependencyAnalysis\StackTraceDocumentsNode.cs (2)

77position += Encoding.UTF8.GetByteCount(_documents[i]) + 1; 82bw.Write(Encoding.UTF8.GetBytes(_documents[i]));

Compiler\ExternSymbolMappedField.cs (1)

24public override Utf8Span Name => System.Text.Encoding.UTF8.GetBytes(_symbolName);

Compiler\Logging\DocumentationSignatureParser.cs (2)

547var type = module.GetType(Encoding.UTF8.GetBytes(namespacepart), Encoding.UTF8.GetBytes(namepart), throwIfNotFound: false);

Compiler\ObjectWriter\CodeView\CodeViewFileTableBuilder.cs (1)

45_stringTableWriter.Write(Encoding.UTF8.GetBytes(fileName));

Compiler\ObjectWriter\CodeView\CodeViewSymbolsBuilder.cs (2)

418int byteCount = Encoding.UTF8.GetByteCount(value) + 1; 419Encoding.UTF8.GetBytes(value, _bufferWriter.GetSpan(byteCount));

Compiler\ObjectWriter\CodeView\CodeViewTypesBuilder.cs (2)

457int byteCount = Encoding.UTF8.GetByteCount(value) + 1; 458Encoding.UTF8.GetBytes(value, _bufferWriter.GetSpan(byteCount));

Compiler\RuntimeConfigurationRootProvider.cs (2)

117byte[] result = new byte[Encoding.UTF8.GetByteCount(s) + 1]; 118Encoding.UTF8.GetBytes(s, result);

Compiler\SourceLinkWriter.cs (1)

50? "{\"documents\":{}}" : Encoding.UTF8.GetString(sourceLinkBytes);

Compiler\SubstitutionProvider.cs (1)

138string resourceStringName = System.Text.Encoding.UTF8.GetString(method.Name.AsSpan().Slice(4));

src\runtime\src\coreclr\tools\Common\Compiler\AsyncContinuationType.cs (1)

25public override Utf8Span Name => Encoding.UTF8.GetBytes(DiagnosticName);

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\CoffObjectWriter.cs (2)

605var nameBytes = Encoding.UTF8.GetByteCount(Name); 608Encoding.UTF8.GetBytes(Name, buffer);

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\MachObjectWriter.cs (3)

1057bool encoded = Encoding.UTF8.TryGetBytes(Name, buffer.Slice(8, 16), out _); 1141bool encoded = Encoding.UTF8.TryGetBytes(SectionName, buffer.Slice(0, 16), out _); 1143encoded = Encoding.UTF8.TryGetBytes(SegmentName, buffer.Slice(16, 16), out _);

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\SectionWriter.cs (5)

134int size = Encoding.UTF8.GetByteCount(value) + 1; 136Encoding.UTF8.GetBytes(value, buffer); 144int size = Encoding.UTF8.GetByteCount(value); 146Encoding.UTF8.GetBytes(value, buffer); 152WriteULEB128((ulong)Encoding.UTF8.GetByteCount(value));

src\runtime\src\coreclr\tools\Common\Compiler\ProcessLinkerXmlBase.cs (3)

794return assembly.GetType(Encoding.UTF8.GetBytes(@namespace), Encoding.UTF8.GetBytes(name), throwIfNotFound: false); 808var nested_type = typeReference.GetNestedType(Encoding.UTF8.GetBytes(names[i]));

src\runtime\src\coreclr\tools\Common\Compiler\TypeMapMetadata.cs (1)

65_name = System.Text.Encoding.UTF8.GetBytes($"InvalidTypeMapStub_{_typeMapGroup}_{(externalTypeMap ? "External" : "Proxy")}");

src\runtime\src\coreclr\tools\Common\Internal\Text\Utf8String.cs (2)

29_value = Encoding.UTF8.GetBytes(s); 40return Encoding.UTF8.GetString(_value);

src\runtime\src\coreclr\tools\Common\Internal\Text\Utf8StringBuilder.cs (4)

83int length = Encoding.UTF8.GetByteCount(value); 86Encoding.UTF8.GetBytes(value, _buffer.AsSpan(_length)); 108return Encoding.UTF8.GetString(_buffer, 0, _length); 113return Encoding.UTF8.GetString(_buffer, start, _length - start);

src\runtime\src\coreclr\tools\Common\TypeSystem\IL\HelperExtensions.cs (6)

79throw new InvalidOperationException(string.Format("Expected method '{0}' not found on type '{1}'", System.Text.Encoding.UTF8.GetString(name), type)); 94throw new InvalidOperationException(string.Format("Expected field '{0}' not found on type '{1}'", System.Text.Encoding.UTF8.GetString(name), type)); 109throw new InvalidOperationException(string.Format("Expected type '{0}' not found on type '{1}'", Encoding.UTF8.GetString(name), type)); 126@namespace.Length > 0 ? string.Concat(Encoding.UTF8.GetString(@namespace), ".", Encoding.UTF8.GetString(name)) : Encoding.UTF8.GetString(name),

src\runtime\src\coreclr\tools\Common\TypeSystem\IL\Stubs\TypeGetTypeMethodThunk.cs (1)

43return System.Text.Encoding.UTF8.GetBytes($"{_helperMethod.GetName()}_{Signature.Length}_{DefaultAssemblyName}");

PdbWriter.cs (3)

315BinaryWriter writer = new BinaryWriter(stringTableStream, Encoding.UTF8); 349BinaryWriter writer = new BinaryWriter(checksumStream, Encoding.UTF8); 400BinaryWriter writer = new BinaryWriter(symbolStream, Encoding.UTF8);

src\runtime\src\coreclr\tools\Common\Internal\NativeFormat\NativeFormatReader.String.cs (1)

76value = Encoding.UTF8.GetString(_base + offset, (int)numBytes);

Compiler\CallChainProfile.cs (1)

235var resolvedMethod = resolvedType.GetMethod(Encoding.UTF8.GetBytes(methodName), null);

Compiler\DependencyAnalysis\ReadyToRun\AttributePresenceFilterNode.cs (1)

347int hashOfAttribute = VersionResilientHashCode.NameHashCode(System.Text.Encoding.UTF8.GetBytes(name));

Compiler\DependencyAnalysis\ReadyToRun\DebugDirectoryEntryNode.cs (3)

122builder.EmitBytes(Encoding.UTF8.GetBytes(_entryName)); 191byte[] pdbFileNameBytes = Encoding.UTF8.GetBytes(pdbFileName); 215byte[] pdbFileNameBytes = Encoding.UTF8.GetBytes(pdbFileName);

Compiler\DependencyAnalysis\ReadyToRun\InjectStringThunksSignature.cs (1)

40byte[] stringBytes = Encoding.UTF8.GetBytes(stub.LookupString);

Compiler\DependencyAnalysis\ReadyToRun\OwnerCompositeExecutableNode.cs (1)

39builder.EmitBytes(Encoding.UTF8.GetBytes(_ownerExecutableName));

Compiler\ReadyToRunExternalTypeMapNode.cs (1)

61typeMapHashTable.Append((uint)VersionResilientHashCode.NameHashCode(Encoding.UTF8.GetBytes(key)), typeMapEntriesSection.Place(entry));

IBC\IBCProfileParser.cs (1)

391_logger.Writer.WriteLine($"Ibc TypeToken {ibcToken:x} unable to find nested type '{Encoding.UTF8.GetString(typeName)}' on type '{externalModule.MetadataReader.GetToken(enclosingType):x}'");

IBC\MIbcProfileParser.cs (2)

653var failure = ResolutionFailure.GetTypeLoadResolutionFailure(Encoding.UTF8.GetString(nameSpace.AsSpan()), Encoding.UTF8.GetString(name.AsSpan()), "System.Private.Canon");

src\runtime\src\coreclr\tools\Common\Compiler\AsyncContinuationType.cs (1)

25public override Utf8Span Name => Encoding.UTF8.GetBytes(DiagnosticName);

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\CoffObjectWriter.cs (2)

605var nameBytes = Encoding.UTF8.GetByteCount(Name); 608Encoding.UTF8.GetBytes(Name, buffer);

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\MachObjectWriter.cs (3)

1057bool encoded = Encoding.UTF8.TryGetBytes(Name, buffer.Slice(8, 16), out _); 1141bool encoded = Encoding.UTF8.TryGetBytes(SectionName, buffer.Slice(0, 16), out _); 1143encoded = Encoding.UTF8.TryGetBytes(SegmentName, buffer.Slice(16, 16), out _);

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\SectionWriter.cs (5)

134int size = Encoding.UTF8.GetByteCount(value) + 1; 136Encoding.UTF8.GetBytes(value, buffer); 144int size = Encoding.UTF8.GetByteCount(value); 146Encoding.UTF8.GetBytes(value, buffer); 152WriteULEB128((ulong)Encoding.UTF8.GetByteCount(value));

src\runtime\src\coreclr\tools\Common\Compiler\ProcessLinkerXmlBase.cs (3)

794return assembly.GetType(Encoding.UTF8.GetBytes(@namespace), Encoding.UTF8.GetBytes(name), throwIfNotFound: false); 808var nested_type = typeReference.GetNestedType(Encoding.UTF8.GetBytes(names[i]));

src\runtime\src\coreclr\tools\Common\Compiler\TypeMapMetadata.cs (1)

65_name = System.Text.Encoding.UTF8.GetBytes($"InvalidTypeMapStub_{_typeMapGroup}_{(externalTypeMap ? "External" : "Proxy")}");

src\runtime\src\coreclr\tools\Common\Internal\Text\Utf8String.cs (2)

29_value = Encoding.UTF8.GetBytes(s); 40return Encoding.UTF8.GetString(_value);

src\runtime\src\coreclr\tools\Common\Internal\Text\Utf8StringBuilder.cs (4)

83int length = Encoding.UTF8.GetByteCount(value); 86Encoding.UTF8.GetBytes(value, _buffer.AsSpan(_length)); 108return Encoding.UTF8.GetString(_buffer, 0, _length); 113return Encoding.UTF8.GetString(_buffer, start, _length - start);

src\runtime\src\coreclr\tools\Common\JitInterface\CorInfoImpl.cs (3)

2212*pRequiredBufferSize = (nuint)Encoding.UTF8.GetByteCount(utf16) + 1; 3869int byteCount = Encoding.UTF8.GetByteCount(s); 3871Encoding.UTF8.GetBytes(s, 0, s.Length, bytes, 0);

src\runtime\src\coreclr\tools\Common\TypeSystem\IL\HelperExtensions.cs (6)

79throw new InvalidOperationException(string.Format("Expected method '{0}' not found on type '{1}'", System.Text.Encoding.UTF8.GetString(name), type)); 94throw new InvalidOperationException(string.Format("Expected field '{0}' not found on type '{1}'", System.Text.Encoding.UTF8.GetString(name), type)); 109throw new InvalidOperationException(string.Format("Expected type '{0}' not found on type '{1}'", Encoding.UTF8.GetString(name), type)); 126@namespace.Length > 0 ? string.Concat(Encoding.UTF8.GetString(@namespace), ".", Encoding.UTF8.GetString(name)) : Encoding.UTF8.GetString(name),

src\runtime\src\coreclr\tools\aot\ILCompiler.ReadyToRun\IBC\MIbcProfileParser.cs (2)

653var failure = ResolutionFailure.GetTypeLoadResolutionFailure(Encoding.UTF8.GetString(nameSpace.AsSpan()), Encoding.UTF8.GetString(name.AsSpan()), "System.Private.Canon");

src\runtime\src\coreclr\tools\Common\JitInterface\CorInfoImpl.cs (3)

2212*pRequiredBufferSize = (nuint)Encoding.UTF8.GetByteCount(utf16) + 1; 3869int byteCount = Encoding.UTF8.GetByteCount(s); 3871Encoding.UTF8.GetBytes(s, 0, s.Length, bytes, 0);

src\runtime\src\coreclr\tools\Common\TypeSystem\IL\HelperExtensions.cs (6)

79throw new InvalidOperationException(string.Format("Expected method '{0}' not found on type '{1}'", System.Text.Encoding.UTF8.GetString(name), type)); 94throw new InvalidOperationException(string.Format("Expected field '{0}' not found on type '{1}'", System.Text.Encoding.UTF8.GetString(name), type)); 109throw new InvalidOperationException(string.Format("Expected type '{0}' not found on type '{1}'", Encoding.UTF8.GetString(name), type)); 126@namespace.Length > 0 ? string.Concat(Encoding.UTF8.GetString(@namespace), ".", Encoding.UTF8.GetString(name)) : Encoding.UTF8.GetString(name),

src\runtime\src\coreclr\tools\Common\Internal\Text\Utf8Span.cs (2)

40return Encoding.UTF8.GetString(_value) == value; 59public override string ToString() => Encoding.UTF8.GetString(_value);

src\runtime\src\coreclr\tools\Common\TypeSystem\Common\DefType.cs (2)

23public string GetNamespace() => System.Text.Encoding.UTF8.GetString(Namespace 36public string GetName() => System.Text.Encoding.UTF8.GetString(Name

src\runtime\src\coreclr\tools\Common\TypeSystem\Common\FieldDesc.cs (1)

44return System.Text.Encoding.UTF8.GetString(

src\runtime\src\coreclr\tools\Common\TypeSystem\Common\ImpliedRepeatedFieldDesc.cs (1)

47public override Utf8Span Name => System.Text.Encoding.UTF8.GetBytes($"{_underlyingFieldDesc.GetName()}[{FieldIndex}]");

src\runtime\src\coreclr\tools\Common\TypeSystem\Common\MetadataTypeSystemContext.cs (1)

75MetadataType type = systemModule.GetType("System"u8, System.Text.Encoding.UTF8.GetBytes(s_wellKnownTypeNames[typeIndex]), throwIfNotFound: typeIndex == (int)WellKnownType.Object);

src\runtime\src\coreclr\tools\Common\TypeSystem\Common\MethodDesc.cs (1)

601return System.Text.Encoding.UTF8.GetString(Name

src\runtime\src\coreclr\tools\Common\TypeSystem\Common\Utilities\CustomAttributeTypeNameParser.cs (3)

190return ((MetadataType)type).GetNestedType(System.Text.Encoding.UTF8.GetBytes(TypeName.Unescape(typeName.Name))); 202System.Text.Encoding.UTF8.GetBytes(TypeName.Unescape(typeName.Namespace)), 203System.Text.Encoding.UTF8.GetBytes(TypeName.Unescape(typeName.Name)), throwIfNotFound: false);

src\runtime\src\coreclr\tools\Common\TypeSystem\Ecma\CachingMetadataStringDecoder.cs (1)

37: base(System.Text.Encoding.UTF8)

src\runtime\src\coreclr\tools\Common\TypeSystem\Ecma\EcmaModule.cs (6)

445var failure = ResolutionFailure.GetTypeLoadResolutionFailure(Encoding.UTF8.GetString(nameSpace.ToArray()), Encoding.UTF8.GetString(name.ToArray()), this); 609return ResolutionFailure.GetMissingFieldFailure(parentTypeDesc, System.Text.Encoding.UTF8.GetString(name.ToArray())); 661return ResolutionFailure.GetMissingMethodFailure(parentTypeDesc, System.Text.Encoding.UTF8.GetString(name.ToArray()), sig); 701return ResolutionFailure.GetTypeLoadResolutionFailure(Encoding.UTF8.GetString(typeName), ((MetadataType)resolutionScope).Module); 745return ResolutionFailure.GetTypeLoadResolutionFailure(Encoding.UTF8.GetString(name), this);

src\runtime\src\coreclr\tools\Common\TypeSystem\IL\HelperExtensions.cs (6)

79throw new InvalidOperationException(string.Format("Expected method '{0}' not found on type '{1}'", System.Text.Encoding.UTF8.GetString(name), type)); 94throw new InvalidOperationException(string.Format("Expected field '{0}' not found on type '{1}'", System.Text.Encoding.UTF8.GetString(name), type)); 109throw new InvalidOperationException(string.Format("Expected type '{0}' not found on type '{1}'", Encoding.UTF8.GetString(name), type)); 126@namespace.Length > 0 ? string.Concat(Encoding.UTF8.GetString(@namespace), ".", Encoding.UTF8.GetString(name)) : Encoding.UTF8.GetString(name),

src\runtime\src\coreclr\tools\Common\TypeSystem\RuntimeDetermined\RuntimeDeterminedType.cs (1)

107return new Utf8Span(System.Text.Encoding.UTF8.GetBytes(_runtimeDeterminedDetailsType.Name))

Linker\CustomSymbolWriter.cs (2)

76writer.Write(Encoding.UTF8.GetBytes(GetOriginalPdbPath())); 107return Encoding.UTF8.GetString(

SafeKeychainHandle.cs (2)

51byte[] utf8Passphrase = Encoding.UTF8.GetBytes(passphrase); 78byte[] utf8Passphrase = Encoding.UTF8.GetBytes(passphrase);

Helpers.cs (1)

26var dirHash = Convert.ToBase64String(hasher.ComputeHash(Encoding.UTF8.GetBytes(normalizedPath)));

ZipArchiveManager.cs (1)

45=> AddContentToArchive(archivePath, targetFilename, new MemoryStream(Encoding.UTF8.GetBytes(content)));

Internal\AntiforgeryOptionsSetup.cs (1)

34byte[] fullHash = SHA256.HashData(Encoding.UTF8.GetBytes(applicationId));

Internal\DefaultAntiforgeryTokenSerializer.cs (2)

208var usernameByteCount = Encoding.UTF8.GetByteCount(token.Username!); 212var additionalDataByteCount = Encoding.UTF8.GetByteCount(token.AdditionalData);

Internal\DefaultClaimUidExtractor.cs (1)

122var byteCount = System.Text.Encoding.UTF8.GetByteCount(parameters[i]);

src\aspnetcore\src\Shared\Encoding\Int7BitEncodingUtils.cs (4)

107var stringByteCount = Encoding.UTF8.GetByteCount(value); 110Encoding.UTF8.GetBytes(value.AsSpan(), target[lengthPrefixSize..]); 131var stringByteCount = Encoding.UTF8.GetByteCount(value); 157value = Encoding.UTF8.GetString(bytes.Slice(consumed, length));

MicrosoftAccountHandler.cs (1)

88var challengeBytes = SHA256.HashData(Encoding.UTF8.GetBytes(codeVerifier));

Internal\LdapAdapter.cs (2)

93var groupDN = $"{Encoding.UTF8.GetString((byte[])group)}"; 157var nestedGroupDN = $"{Encoding.UTF8.GetString((byte[])member)}";

OAuthHandler.cs (1)

322var challengeBytes = SHA256.HashData(Encoding.UTF8.GetBytes(codeVerifier));

OpenIdConnectHandler.cs (3)

293var buffer = Encoding.UTF8.GetBytes(content); 425var challengeBytes = SHA256.HashData(Encoding.UTF8.GetBytes(codeVerifier)); 540var buffer = Encoding.UTF8.GetBytes(content);

OpenIdConnectPostConfigureOptions.cs (2)

114return Encoding.UTF8.GetString(data); 119return Encoding.UTF8.GetBytes(model);

PersistentState\PersistentServicesRegistry.cs (1)

248var input = Encoding.UTF8.GetBytes(inputString);

PersistentState\PersistentStateValueProviderKeyResolver.cs (2)

96wroteKey = Encoding.UTF8.TryGetBytes(keySpan, currentBuffer, out var written); 188SHA256.HashData(Encoding.UTF8.GetBytes(string.Join(".", parts.parentComponentType, parts.componentType, parts.propertyName)));

Routing\RouteContext.cs (2)

29if (Encoding.UTF8.TryGetBytes(path.AsSpan(), utf8Span, out var written)) 34path = Encoding.UTF8.GetString(utf8Span);

Builder\ResourceCollectionUrlEndpoint.cs (3)

172if (Encoding.UTF8.TryGetBytes(value, buffer, out var written)) 178var length = Encoding.UTF8.GetByteCount(value); 186var bytesWritten = Encoding.UTF8.GetBytes(value, rented);

CacheView\CacheViewKeyResolver.cs (3)

261var byteCount = Encoding.UTF8.GetByteCount(value); 276var byteCount = Encoding.UTF8.GetByteCount(value); 283var written = Encoding.UTF8.GetBytes(value, buffer);

Forms\ClientValidationDataWriter.cs (1)

112var result = _anyField ? Encoding.UTF8.GetString(_buffer.WrittenSpan) : null;

RazorComponentEndpointInvoker.cs (1)

89await using var writer = new HttpResponseStreamWriter(context.Response.Body, Encoding.UTF8, defaultBufferSize, ArrayPool<byte>.Shared, ArrayPool<char>.Shared);

Rendering\Buffering\BufferedTextWriter.cs (1)

23public override Encoding Encoding => Encoding.UTF8;

Rendering\EndpointHtmlRenderer.EventDispatch.cs (2)

100await using var writer = new HttpResponseStreamWriter(_httpContext.Response.Body, Encoding.UTF8, defaultBufferSize, ArrayPool<byte>.Shared, ArrayPool<char>.Shared); 132await using var writer = new HttpResponseStreamWriter(_httpContext.Response.Body, Encoding.UTF8, defaultBufferSize, ArrayPool<byte>.Shared, ArrayPool<char>.Shared);

Rendering\EndpointHtmlRenderer.Streaming.cs (2)

103var initializersBase64 = Convert.ToBase64String(Encoding.UTF8.GetBytes(_options.JavaScriptInitializers)); 463var configBase64 = Convert.ToBase64String(Encoding.UTF8.GetBytes(configJson));

Rendering\TypeNameHash.cs (2)

23if (!Encoding.UTF8.TryGetBytes(typeName, typeNameBytes, out var written)) 25typeNameBytes = Encoding.UTF8.GetBytes(typeName);

Results\RazorComponentResultExecutor.cs (1)

65await using var writer = new HttpResponseStreamWriter(httpContext.Response.Body, Encoding.UTF8, defaultBufferSize, ArrayPool<byte>.Shared, ArrayPool<char>.Shared);

Circuits\CircuitPersistenceManager.cs (2)

73var rootComponents = Encoding.UTF8.GetString(state.RootComponents); 84var rootComponentsBytes = Encoding.UTF8.GetBytes(rootComponents);

Circuits\ServerComponentDeserializer.cs (1)

249unprotected = Encoding.UTF8.GetString(unprotectedBytes);

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

53_binaryWriter = new BinaryWriter(output, Encoding.UTF8, leaveOpen);

src\aspnetcore\src\SignalR\common\Protocols.MessagePack\src\Protocol\MessagePackHubProtocolWorker.cs (1)

658return binder.GetTarget(span) ?? Encoding.UTF8.GetString(span);

GenerateE2EManifest.cs (1)

188using var writer = JsonReaderWriterFactory.CreateJsonWriter(fileStream, Encoding.UTF8, ownsStream: false, indent: true);

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

53_binaryWriter = new BinaryWriter(output, Encoding.UTF8, leaveOpen);

TargetPickerUi.cs (5)

54var bytes = Encoding.UTF8.GetBytes(msg); 55var bytesWithHeader = Encoding.UTF8.GetBytes($"{bytes.Length}:").Concat(bytes).ToArray(); 74$"after reading {bytesRead} bytes. Instead got: {Encoding.UTF8.GetString(_lengthBuffer)}"); 80string str = Encoding.UTF8.GetString(_lengthBuffer, 0, bytesRead - 1); 95var messageReceived = Encoding.UTF8.GetString(buffer, 0, messageLen);

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

53_binaryWriter = new BinaryWriter(output, Encoding.UTF8, leaveOpen);

StaticContentProvider.cs (1)

45content = new MemoryStream(Encoding.UTF8.GetBytes($"There is no content at {relativePath}"));

src\BlazorWebView\src\SharedSource\StaticContentHotReloadManager.cs (1)

41 { (ApplicationAssemblyName, "_framework/static-content-hot-reload.js"), ("text/javascript", Encoding.UTF8.GetBytes(NotifyCssUpdatedScript)) }

src\BlazorWebView\src\SharedSource\StaticContentHotReloadManager.cs (1)

41 { (ApplicationAssemblyName, "_framework/static-content-hot-reload.js"), ("text/javascript", Encoding.UTF8.GetBytes(NotifyCssUpdatedScript)) }

src\BlazorWebView\src\SharedSource\StaticContentHotReloadManager.cs (1)

41 { (ApplicationAssemblyName, "_framework/static-content-hot-reload.js"), ("text/javascript", Encoding.UTF8.GetBytes(NotifyCssUpdatedScript)) }

PBKDF2\ManagedPbkdf2Provider.cs (1)

71byte[] passwordBytes = Encoding.UTF8.GetBytes(password);

PBKDF2\Win7Pbkdf2Provider.cs (2)

30int cbPasswordBuffer = Encoding.UTF8.GetMaxByteCount(password.Length); 52cbPasswordBufferUsed = Encoding.UTF8.GetBytes(pszPassword, password.Length, pbPasswordBuffer, cbPasswordBuffer);

PBKDF2\Win8Pbkdf2Provider.cs (2)

64int cbPasswordBuffer = Encoding.UTF8.GetMaxByteCount(password.Length); 86cbPasswordBufferUsed = Encoding.UTF8.GetBytes(pszPassword, password.Length, pbPasswordBuffer, cbPasswordBuffer);

Cng\DpapiSecretSerializerHelper.cs (1)

24private static readonly byte[] _purpose = Encoding.UTF8.GetBytes("DPAPI-Protected Secret");

src\aspnetcore\src\Shared\Encoding\Int7BitEncodingUtils.cs (4)

107var stringByteCount = Encoding.UTF8.GetByteCount(value); 110Encoding.UTF8.GetBytes(value.AsSpan(), target[lengthPrefixSize..]); 131var stringByteCount = Encoding.UTF8.GetByteCount(value); 157value = Encoding.UTF8.GetString(bytes.Slice(consumed, length));

src\aspnetcore\src\Shared\Diagnostics\BaseView.cs (1)

66Output = new StreamWriter(Response.Body, Encoding.UTF8, 4096, leaveOpen: true);

src\aspnetcore\src\Shared\Diagnostics\BaseView.cs (1)

66Output = new StreamWriter(Response.Body, Encoding.UTF8, 4096, leaveOpen: true);

HealthCheckResponseWriters.cs (3)

12private static readonly byte[] DegradedBytes = Encoding.UTF8.GetBytes(HealthStatus.Degraded.ToString()); 13private static readonly byte[] HealthyBytes = Encoding.UTF8.GetBytes(HealthStatus.Healthy.ToString()); 14private static readonly byte[] UnhealthyBytes = Encoding.UTF8.GetBytes(HealthStatus.Unhealthy.ToString());

Internal\JsonRequestHelpers.cs (3)

58if (encoding == null || encoding.CodePage == Encoding.UTF8.CodePage) 63var stream = Encoding.CreateTranscodingStream(innerStream, encoding, Encoding.UTF8, leaveOpen: true); 73return Encoding.UTF8;

Internal\JsonTranscodingServerCallContext.cs (2)

32public Encoding RequestEncoding { get; private set; } = Encoding.UTF8; 52RequestEncoding = JsonRequestHelpers.GetEncodingFromCharset(charset) ?? Encoding.UTF8;

src\aspnetcore\src\Grpc\JsonTranscoding\src\Shared\AuthContextHelpers.cs (1)

67values.Add(AuthProperty.Create(name, Encoding.UTF8.GetBytes(value)));

Features\FormFeature.cs (1)

340return Encoding.UTF8;

Extensions\HttpResponseWritingExtensions.cs (2)

31return response.WriteAsync(text, Encoding.UTF8, cancellationToken); 92if (encoding == Encoding.UTF8)

HttpRequestJsonExtensions.cs (11)

80if (encoding == null || encoding.CodePage == Encoding.UTF8.CodePage) 93inputStream = Encoding.CreateTranscodingStream(request.Body, encoding, Encoding.UTF8, leaveOpen: true); 136if (encoding == null || encoding.CodePage == Encoding.UTF8.CodePage) 149inputStream = Encoding.CreateTranscodingStream(request.Body, encoding, Encoding.UTF8, leaveOpen: true); 192if (encoding == null || encoding.CodePage == Encoding.UTF8.CodePage) 205inputStream = Encoding.CreateTranscodingStream(request.Body, encoding, Encoding.UTF8, leaveOpen: true); 272if (encoding == null || encoding.CodePage == Encoding.UTF8.CodePage) 285inputStream = Encoding.CreateTranscodingStream(request.Body, encoding, Encoding.UTF8, leaveOpen: true); 332if (encoding == null || encoding.CodePage == Encoding.UTF8.CodePage) 345inputStream = Encoding.CreateTranscodingStream(request.Body, encoding, Encoding.UTF8, leaveOpen: true); 415return Encoding.UTF8;

SessionExtensions.cs (2)

54session.Set(key, Encoding.UTF8.GetBytes(value)); 69return Encoding.UTF8.GetString(data);

HttpResultsHelper.cs (1)

21private static readonly Encoding DefaultEncoding = Encoding.UTF8;

MediaTypeHelpers.cs (1)

15Encoding.UTF8,

MediaTypeOptions.cs (6)

25options.AddText("application/json", Encoding.UTF8); 26options.AddText("application/*+json", Encoding.UTF8); 27options.AddText("application/xml", Encoding.UTF8); 28options.AddText("application/*+xml", Encoding.UTF8); 29options.AddText("text/*", Encoding.UTF8); 38mediaType.Encoding ??= Encoding.UTF8;

IdentityApiEndpointRouteBuilderExtensions.cs (4)

154code = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(code)); 215code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code)); 242var code = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(resetRequest.ResetCode)); 400code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));

PasskeyHandler.cs (1)

626var originalRpIdHash = SHA256.HashData(Encoding.UTF8.GetBytes(originalRpId ?? string.Empty));

Passkeys\BufferSource.cs (2)

40var buffer = Encoding.UTF8.GetBytes(value); 124return Encoding.UTF8.GetString(span);

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

56code = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(code));

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

58code = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(code));

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

201code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));

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

76code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));

Areas\Identity\Pages\V4\Account\Manage\Email.cshtml.cs (2)

141code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code)); 174code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));

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

141code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));

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

77code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));

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

88code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));

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

100Code = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(code))

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

56code = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(code));

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

58code = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(code));

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

201code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));

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

76code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));

Areas\Identity\Pages\V5\Account\Manage\Email.cshtml.cs (2)

141code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code)); 174code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));

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

141code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));

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

77code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));

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

88code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));

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

100Code = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(code))

Formatters\StringOutputFormatter.cs (1)

20SupportedEncodings.Add(Encoding.UTF8);

Formatters\SystemTextJsonInputFormatter.cs (2)

71if (encoding.CodePage == Encoding.UTF8.CodePage) 84inputStream = Encoding.CreateTranscodingStream(httpContext.Request.Body, encoding, Encoding.UTF8, leaveOpen: true);

Formatters\SystemTextJsonOutputFormatter.cs (3)

28SupportedEncodings.Add(Encoding.UTF8); 86if (selectedEncoding.CodePage == Encoding.UTF8.CodePage) 107var transcodingStream = Encoding.CreateTranscodingStream(httpContext.Response.Body, selectedEncoding, Encoding.UTF8, leaveOpen: true);

Formatters\TextOutputFormatter.cs (2)

45cache.Add(mediaType, MediaType.ReplaceEncoding(mediaType, Encoding.UTF8)); 184if (string.Equals(encoding.WebName, Encoding.UTF8.WebName, StringComparison.OrdinalIgnoreCase) &&

Infrastructure\ContentResultExecutor.cs (1)

44(DefaultContentType, Encoding.UTF8),

Infrastructure\IHttpRequestStreamReaderFactory.cs (1)

19/// <param name="encoding">The <see cref="Encoding"/>, usually <see cref="Encoding.UTF8"/>.</param>

Infrastructure\IHttpResponseStreamWriterFactory.cs (1)

19/// <param name="encoding">The <see cref="Encoding"/>, usually <see cref="Encoding.UTF8"/>.</param>

Infrastructure\SystemTextJsonResultExecutor.cs (4)

20Encoding = Encoding.UTF8 46(DefaultContentType, Encoding.UTF8), 64if (resolvedContentTypeEncoding.CodePage == Encoding.UTF8.CodePage) 77var transcodingStream = Encoding.CreateTranscodingStream(response.Body, resolvedContentTypeEncoding, Encoding.UTF8, leaveOpen: true);

src\aspnetcore\src\Shared\MediaType\ReadOnlyMediaTypeHeaderValue.cs (1)

353return Encoding.UTF8;

XmlDataContractSerializerOutputFormatter.cs (1)

68SupportedEncodings.Add(Encoding.UTF8);

XmlSerializerOutputFormatter.cs (1)

67SupportedEncodings.Add(Encoding.UTF8);

NewtonsoftJsonOutputFormatter.cs (1)

69SupportedEncodings.Add(Encoding.UTF8);

NewtonsoftJsonResultExecutor.cs (2)

24Encoding = Encoding.UTF8 80(DefaultContentType, Encoding.UTF8),

RuntimeViewCompiler.cs (1)

374var sourceText = SourceText.From(compilationContent, Encoding.UTF8);

Cache\CacheTagKey.cs (1)

180var contentBytes = Encoding.UTF8.GetBytes(key);

Cache\DistributedCacheTagHelperFormatter.cs (2)

28var serialized = Encoding.UTF8.GetBytes(context.Html.ToString()); 37var content = Encoding.UTF8.GetString(value);

Cache\DistributedCacheTagHelperService.cs (1)

83var serializedKey = Encoding.UTF8.GetBytes(key.GenerateKey());

PartialTagHelper.cs (1)

142using (var writer = new ViewBufferTextWriter(viewBuffer, Encoding.UTF8))

GenerateMvcTestManifestTask.cs (1)

47using var writer = JsonReaderWriterFactory.CreateJsonWriter(fileStream, Encoding.UTF8, ownsStream: false, indent: true);

HtmlHelper.cs (1)

453using (var writer = new ViewBufferTextWriter(viewBuffer, Encoding.UTF8))

ViewComponentResultExecutor.cs (1)

89(ViewExecutor.DefaultContentType, Encoding.UTF8),

ViewExecutor.cs (1)

192(DefaultContentType, Encoding.UTF8),

FormatterBinaryReader.cs (1)

143var s = Encoding.UTF8.GetString(MemoryMarshal.CreateReadOnlySpan(ref Unsafe.Add(ref _root, _offset), bytes));

FormatterBinaryWriter.cs (3)

89var bytes = Encoding.UTF8.GetByteCount(value); 93var actual = Encoding.UTF8.GetBytes(value, AvailableBuffer); 101var actual = Encoding.UTF8.GetBytes(value, target);

RedisOutputCacheStore.cs (3)

83_valueKeyPrefix = (RedisKey)Encoding.UTF8.GetBytes(_options.InstanceName + "__MSOCV_"); 84_tagKeyPrefix = (RedisKey)Encoding.UTF8.GetBytes(_options.InstanceName + "__MSOCT_"); 85_tagMasterKey = (RedisKey)Encoding.UTF8.GetBytes(_options.InstanceName + "__MSOCT");

WebSockets\WebSocketAdapter.cs (1)

109string description = Encoding.UTF8.GetString(buffer.Array, buffer.Offset + 2, buffer.Count - 2);

TagHelpers\DefaultTagHelperContent.cs (1)

310return Encoding.UTF8;

UrlActions\CustomResponseAction.cs (1)

36var content = Encoding.UTF8.GetBytes(StatusDescription);

src\aspnetcore\src\Shared\MediaType\ReadOnlyMediaTypeHeaderValue.cs (1)

353return Encoding.UTF8;

HttpSysOptions.cs (1)

264/// Defaults to <c>false</c>, in which case <see cref="Encoding.UTF8"/> will be used. />.

src\aspnetcore\src\Shared\Buffers.MemoryPool\UnmanagedBufferAllocator.cs (2)

88int maxAlloc = checked(Encoding.UTF8.GetMaxByteCount(myString.Length) + 1); 90length = Encoding.UTF8.GetBytes(myString, buffer);

src\aspnetcore\src\Shared\HttpSys\RequestProcessing\HeaderEncoding.cs (1)

20header = new ReadOnlySpan<byte>(pBytes, byteCount).GetAsciiOrUTF8String(Encoding.UTF8);

Core\IISHttpContext.cs (3)

667var headerValueBytes = Encoding.UTF8.GetBytes(headerValue); 673var headerNameBytes = Encoding.UTF8.GetBytes(headerPair.Key); 712var headerValueBytes = Encoding.UTF8.GetBytes(headerValue);

src\aspnetcore\src\Shared\Buffers.MemoryPool\UnmanagedBufferAllocator.cs (2)

88int maxAlloc = checked(Encoding.UTF8.GetMaxByteCount(myString.Length) + 1); 90length = Encoding.UTF8.GetBytes(myString, buffer);

src\aspnetcore\src\Shared\HttpSys\RequestProcessing\HeaderEncoding.cs (1)

20header = new ReadOnlySpan<byte>(pBytes, byteCount).GetAsciiOrUTF8String(Encoding.UTF8);

Internal\Http\PathDecoder.cs (1)

33return Encoding.UTF8.GetString(path.Slice(0, pathLength));

Internal\Infrastructure\KestrelEventSource.cs (2)

195var applicationProtocol = feature == null ? string.Empty : Encoding.UTF8.GetString(feature.ApplicationProtocol.Span); 244var serializedConfig = Encoding.UTF8.GetString(bufferWriter.WrittenSpan);

src\aspnetcore\src\Shared\Buffers.MemoryPool\UnmanagedBufferAllocator.cs (2)

88int maxAlloc = checked(Encoding.UTF8.GetMaxByteCount(myString.Length) + 1); 90length = Encoding.UTF8.GetBytes(myString, buffer);

src\aspnetcore\src\Shared\Buffers.MemoryPool\UnmanagedBufferAllocator.cs (2)

88int maxAlloc = checked(Encoding.UTF8.GetMaxByteCount(myString.Length) + 1); 90length = Encoding.UTF8.GetBytes(myString, buffer);

src\aspnetcore\src\Shared\Buffers.MemoryPool\UnmanagedBufferAllocator.cs (2)

88int maxAlloc = checked(Encoding.UTF8.GetMaxByteCount(myString.Length) + 1); 90length = Encoding.UTF8.GetBytes(myString, buffer);

CookieProtection.cs (2)

20var userData = Encoding.UTF8.GetBytes(data); 47return Encoding.UTF8.GetString(userData);

EncodedKey.cs (2)

18KeyBytes = Encoding.UTF8.GetBytes(key); 32_keyString = Encoding.UTF8.GetString(KeyBytes, 0, KeyBytes.Length);

HubClientProxyGenerator.Emitter.cs (2)

123_context.AddSource("HubClientProxy.g.cs", SourceText.From(extensions.ToString(), Encoding.UTF8)); 192_context.AddSource($"HubClientProxy.{typeSpec.TypeName}.g.cs", SourceText.From(registrationMethodBody.ToString(), Encoding.UTF8));

HubServerProxyGenerator.Emitter.cs (2)

75_context.AddSource("HubServerProxy.g.cs", SourceText.From(getProxy.ToString(), Encoding.UTF8)); 163_context.AddSource($"HubServerProxy.{classSpec.ClassTypeName}.g.cs", SourceText.From(proxy.ToString(), Encoding.UTF8));

Protocol\HandshakeProtocol.cs (1)

228return Encoding.UTF8.GetString(payload.ToArray());

src\aspnetcore\src\SignalR\common\Shared\Utf8BufferTextReader.cs (1)

26_decoder = Encoding.UTF8.GetDecoder();

Internal\Utf8HashLookup.cs (3)

42var encodedValue = Encoding.UTF8.GetBytes(value); 84var count = Encoding.UTF8.GetCharCount(encodedValue); 88var encoded = Encoding.UTF8.GetChars(encodedValue, chars);

src\aspnetcore\src\SignalR\common\Shared\Utf8BufferTextReader.cs (1)

26_decoder = Encoding.UTF8.GetDecoder();

Protocol\MessagePackHubProtocolWorker.cs (1)

658return binder.GetTarget(span) ?? Encoding.UTF8.GetString(span);

Protocol\NewtonsoftJsonHubProtocol.cs (1)

605writer.WriteRawValue(Encoding.UTF8.GetString(result.RawSerializedData));

src\aspnetcore\src\SignalR\common\Shared\Utf8BufferTextReader.cs (1)

26_decoder = Encoding.UTF8.GetDecoder();

RedisHubLifetimeManager.cs (1)

841public override Encoding Encoding => Encoding.UTF8;

SpaProxyMiddleware.cs (1)

62await using var writer = new StreamWriter(context.Response.Body, Encoding.UTF8);

HtmlDirectoryFormatter.cs (1)

204byte[] bytes = Encoding.UTF8.GetBytes(data);

src\sdk\src\Dotnet.Watch\Web.Middleware\BrowserScriptMiddleware.cs (1)

75return Encoding.UTF8.GetBytes(script);

src\sdk\src\Dotnet.Watch\Web.Middleware\ScriptInjectingStream.cs (1)

21private static readonly ReadOnlyMemory<byte> s_injectedScriptBytes = Encoding.UTF8.GetBytes(InjectedScript);

HandshakeHelpers.cs (1)

61Encoding.UTF8.GetBytes(requestKey, mergedBytes);

BufferedReadStream.cs (1)

425return Encoding.UTF8.GetString(builder.GetBuffer(), 0, (int)length);

FormPipeReader.cs (5)

44: this(pipeReader, Encoding.UTF8) 64if (_encoding != Encoding.UTF8 && _encoding != Encoding.ASCII) 392else if (_encoding == Encoding.UTF8 || _encoding == Encoding.ASCII) 424if (_encoding == Encoding.UTF8 || _encoding == Encoding.ASCII) 436if (_encoding == Encoding.UTF8 || _encoding == Encoding.ASCII)

FormReader.cs (1)

74: this(stream, Encoding.UTF8, ArrayPool<char>.Shared)

MultipartBoundary.cs (1)

18_boundaryBytes = Encoding.UTF8.GetBytes("\r\n--" + boundary);

MultipartSectionStreamExtensions.cs (1)

43streamEncoding = Encoding.UTF8;

BackEnd\BuildManager\CoordinatorClient.Connection.cs (2)

40_reader = new BinaryReader(pipeStream, Encoding.UTF8, leaveOpen: true); 41_writer = new BinaryWriter(pipeStream, Encoding.UTF8, leaveOpen: true);

Construction\ProjectRootElement.cs (1)

77private static readonly Encoding s_defaultEncoding = Encoding.UTF8;

Evaluation\IntrinsicFunctions.cs (3)

399return Convert.ToBase64String(Encoding.UTF8.GetBytes(toEncode)); 409return Encoding.UTF8.GetString(Convert.FromBase64String(toDecode)); 450SHA256.HashData(Encoding.UTF8.GetBytes(toHash), hash);

Logging\BinaryLogger\ProjectImportsCollector.cs (1)

193using var content = new MemoryStream(Encoding.UTF8.GetBytes(data));

Logging\FileLogger.cs (1)

45_encoding = Encoding.UTF8;

Logging\TerminalLogger\Terminal.cs (2)

92Console.OutputEncoding = Encoding.UTF8; 105_originalOutputEncoding = Encoding.UTF8;

Utilities\EncodingStringWriter.cs (1)

26Encoding = encoding ?? Encoding.UTF8;

BackEnd\InterningBinaryReader.cs (3)

56: base(input, Encoding.UTF8) 65_decoder = Encoding.UTF8.GetDecoder(); 269_byteBuffer ??= new byte[Encoding.UTF8.GetMaxByteCount(MaxCharsBuffer)];

BackEnd\ServerNodeHandshake.cs (1)

69byte[] utf8 = Encoding.UTF8.GetBytes(key);

Coordinator\CoordinatorSettings.cs (2)

151int byteCount = Encoding.UTF8.GetByteCount(PipeName); 156Encoding.UTF8.GetBytes(PipeName, pipeNameBytes);

EncodingUtilities.cs (5)

56s_currentOemEncoding = Encoding.UTF8; 123return SimilarToEncoding(encoding, Encoding.UTF8); 133return StartsWithPreamble(stream, Encoding.UTF8.GetPreamble()); 282Console.OutputEncoding = Encoding.UTF8; 284Console.InputEncoding = Encoding.UTF8;

Telemetry\CrashTelemetry.cs (1)

815byte[] hashBytes = SHA256.HashData(Encoding.UTF8.GetBytes(stackTrace));

Telemetry\TelemetryDataUtils.cs (1)

139byte[] bytes = Encoding.UTF8.GetBytes(text);

Utilities\ProcessExtensions.cs (1)

184int charsWritten = Encoding.UTF8.GetChars(segment, charBuffer.AsSpan().Slice(totalChars));

src\roslyn\src\Compilers\Core\MSBuildTask\ManagedCompiler.cs (1)

474return (Utf8Output) ? Encoding.UTF8 : base.StandardOutputEncoding;

src\roslyn\src\Compilers\Shared\BuildServerConnection.cs (1)

703var bytes = sha.ComputeHash(Encoding.UTF8.GetBytes(pipeNameInput));

src\roslyn\src\Compilers\Shared\CompilerServerLogger.cs (1)

155byte[] bytes = Encoding.UTF8.GetBytes(output);

AddToWin32Manifest.cs (1)

186using (var xmlWriter = new XmlTextWriter(outputPath, Encoding.UTF8))

AssemblyDependency\AssemblyInformation.cs (1)

1181var v = Encoding.UTF8.GetString(sr.ReadBytes(length));

BootstrapperUtil\BootstrapperBuilder.cs (1)

2005using (var xmlwriter = new XmlTextWriter(System.IO.Path.Combine(s_logPath, fileName), Encoding.UTF8))

GenerateResource.cs (1)

3879using (StreamWriter writer = FileUtilities.OpenWrite(fileName, false, Encoding.UTF8))

Hash.cs (1)

29private static readonly Encoding s_encoding = Encoding.UTF8;

ManifestUtil\ManifestFormatter.cs (1)

26var w = new XmlTextWriter(m, Encoding.UTF8)

ManifestUtil\ManifestWriter.cs (1)

29using var w = new StreamWriter(m, System.Text.Encoding.UTF8, bufferSize: 1024, leaveOpen: true);

ManifestUtil\mansign2.cs (2)

890byte[] licenseXml = Encoding.UTF8.GetBytes(licenseDom.OuterXml); 912timestamp = Encoding.UTF8.GetString(timestampSignature);

ManifestUtil\Util.cs (1)

508using var r = new StreamReader(s, Encoding.UTF8, detectEncodingFromByteOrderMarks: true, 1024, leaveOpen: true);

ManifestUtil\XmlUtil.cs (1)

122var w = new XmlTextWriter(m, Encoding.UTF8);

ResourceHandling\MSBuildResXReader.cs (1)

325using (var x = new MemoryStream(Encoding.UTF8.GetBytes(resxContent)))

ToolTask.cs (1)

229protected virtual Encoding ResponseFileEncoding => Encoding.UTF8;

CommandLine\CommonCompiler.cs (2)

369using (var reader = new StreamReader(data, Encoding.UTF8)) 1837var bytes = Encoding.UTF8.GetBytes(key);

DiaSymReader\Writer\SymUnmanagedWriterImpl.cs (3)

386byte[] bytes = Encoding.UTF8.GetBytes(value); 388value = Encoding.UTF8.GetString(bytes, 0, bytes.Length); 392encodedLength = Encoding.UTF8.GetByteCount(value);

InternalUtilities\StringTable.cs (1)

413text = Encoding.UTF8.GetString(bytes, utf8Bytes.Length);

MetadataReader\PEModule.cs (1)

4027private StringTableDecoder() : base(System.Text.Encoding.UTF8) { }

PEWriter\MetadataWriter.cs (1)

40internal static readonly Encoding s_utf8Encoding = Encoding.UTF8;

PEWriter\PeWriter.cs (1)

370return path + new string('\0', Math.Max(0, minLength - Encoding.UTF8.GetByteCount(path) - 1));

SourceGeneration\GeneratorContexts.cs (2)

85public void AddSource(string hintName, string source) => AddSource(hintName, SourceText.From(source, Encoding.UTF8, checksumAlgorithm: _checksumAlgorithm == SourceHashAlgorithm.None ? SourceHashAlgorithms.Default : _checksumAlgorithm)); 277public void AddSource(string hintName, string source) => AddSource(hintName, SourceText.From(source, Encoding.UTF8));

SourceGeneration\IncrementalContexts.cs (4)

243public void AddSource(string hintName, string source) => AddSource(hintName, SourceText.From(source, Encoding.UTF8)); 263public void AddEmbeddedAttributeDefinition() => AddSource("Microsoft.CodeAnalysis.EmbeddedAttribute", SourceText.From(_embeddedAttributeDefinition, encoding: Encoding.UTF8)); 292public void AddSource(string hintName, string source) => AddSource(hintName, SourceText.From(source, Encoding.UTF8, checksumAlgorithm: ChecksumAlgorithm == SourceHashAlgorithm.None ? SourceHashAlgorithms.Default : ChecksumAlgorithm)); 351public void AddSource(string hintName, string source) => AddSource(hintName, SourceText.From(source, Encoding.UTF8, checksumAlgorithm: ChecksumAlgorithm == SourceHashAlgorithm.None ? SourceHashAlgorithms.Default : ChecksumAlgorithm));

src\roslyn\src\Dependencies\CodeAnalysis.Debugging\CustomDebugInfoReader.cs (1)

868return Encoding.UTF8.GetString(block, 0, block.Length);

Syntax\SyntaxNode.cs (1)

321/// If an encoding-less <see cref="SourceText"/> is written to a file a <see cref="Encoding.UTF8"/> shall be used as a default.

Text\SourceText.cs (6)

100/// If an encoding-less <see cref="SourceText"/> is written to a file a <see cref="Encoding.UTF8"/> shall be used as a default. 126/// If an encoding-less <see cref="SourceText"/> is written to a file a <see cref="Encoding.UTF8"/> shall be used as a default. 165/// <see cref="Encoding.UTF8"/> if not specified. 237/// <see cref="Encoding.UTF8"/> if not specified. 394/// If an encoding-less <see cref="SourceText"/> is written to a file a <see cref="Encoding.UTF8"/> shall be used as a default. 1308return Encoding.UTF8;

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\StringTable.cs (1)

413text = Encoding.UTF8.GetString(bytes, utf8Bytes.Length);

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\SourceTextExtensions.cs (1)

38using (var writer = new StreamWriter(stream, Encoding.UTF8, 1024, true))

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\StringExtensions.cs (1)

15return Encoding.UTF8.GetByteCount(value) == value.Length;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectReader.cs (1)

47_reader = new BinaryReader(stream, Encoding.UTF8, leaveOpen);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectWriter.cs (1)

94_writer = new BinaryWriter(stream, Encoding.UTF8, leaveOpen);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\TextEncodingKind.cs (3)

45TextEncodingKind.EncodingUtf8_BOM => Encoding.UTF8, 82Debug.Assert(HasPreamble(Encoding.UTF8)); 83kind = (encoding.Equals(Encoding.UTF8) || HasPreamble(encoding)) ? TextEncodingKind.EncodingUtf8_BOM : TextEncodingKind.EncodingUtf8;

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\StringTable.cs (1)

413text = Encoding.UTF8.GetString(bytes, utf8Bytes.Length);

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\SourceTextExtensions.cs (1)

38using (var writer = new StreamWriter(stream, Encoding.UTF8, 1024, true))

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\StringExtensions.cs (1)

15return Encoding.UTF8.GetByteCount(value) == value.Length;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectReader.cs (1)

47_reader = new BinaryReader(stream, Encoding.UTF8, leaveOpen);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectWriter.cs (1)

94_writer = new BinaryWriter(stream, Encoding.UTF8, leaveOpen);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\TextEncodingKind.cs (3)

45TextEncodingKind.EncodingUtf8_BOM => Encoding.UTF8, 82Debug.Assert(HasPreamble(Encoding.UTF8)); 83kind = (encoding.Equals(Encoding.UTF8) || HasPreamble(encoding)) ? TextEncodingKind.EncodingUtf8_BOM : TextEncodingKind.EncodingUtf8;

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\StringTable.cs (1)

413text = Encoding.UTF8.GetString(bytes, utf8Bytes.Length);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectReader.cs (1)

47_reader = new BinaryReader(stream, Encoding.UTF8, leaveOpen);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectWriter.cs (1)

94_writer = new BinaryWriter(stream, Encoding.UTF8, leaveOpen);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\TextEncodingKind.cs (3)

45TextEncodingKind.EncodingUtf8_BOM => Encoding.UTF8, 82Debug.Assert(HasPreamble(Encoding.UTF8)); 83kind = (encoding.Equals(Encoding.UTF8) || HasPreamble(encoding)) ? TextEncodingKind.EncodingUtf8_BOM : TextEncodingKind.EncodingUtf8;

Syntax\CSharpSyntaxTree.Dummy.cs (1)

46get { return Encoding.UTF8; }

Syntax\SyntaxFactory.cs (1)

1952return SourceText.From(text, Encoding.UTF8).GetSubText(offset);

SyncedSource\FileBasedPrograms\Sha256Hasher.cs (1)

19return Convert.ToHexStringLower(SHA256.HashData(Encoding.UTF8.GetBytes(text)));

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.AbstractGlobalSuppressMessageCodeAction.cs (1)

109var emptyText = SourceText.From("", Encoding.UTF8, SourceHashAlgorithms.Default);

EditAndContinue\TraceLog.cs (1)

117using var writer = new StreamWriter(file, text.Encoding ?? Encoding.UTF8);

MetadataAsSource\MetadataAsSourceGeneratedFileInfo.cs (1)

21public static Encoding Encoding => Encoding.UTF8;

PdbSourceDocument\PdbSourceDocumentMetadataAsSourceFileProvider.cs (1)

250var encoding = defaultEncoding ?? Encoding.UTF8;

src\roslyn\src\Dependencies\CodeAnalysis.Debugging\CustomDebugInfoReader.cs (1)

868return Encoding.UTF8.GetString(block, 0, block.Length);

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\Compiler\Extensions\SourceTextExtensions.cs (1)

37using (var writer = new StreamWriter(stream, Encoding.UTF8, 1024, true))

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\Compiler\Extensions\StringExtensions.cs (1)

51return Encoding.UTF8.GetByteCount(value) == value.Length;

Language\CodeGeneration\CodeWriter.cs (1)

309return SourceText.From(reader, Length, Encoding.UTF8);

Language\InMemoryFileContent.cs (2)

19var preamble = Encoding.UTF8.GetPreamble(); 20var contentBytes = Encoding.UTF8.GetBytes(content);

Language\RazorSourceDocument.cs (4)

164/// <remarks>Uses <see cref="System.Text.Encoding.UTF8" /></remarks> 172return Create(content, fileName, Encoding.UTF8); 182/// <remarks>Uses <see cref="System.Text.Encoding.UTF8" /></remarks> 195return Create(content, Encoding.UTF8, properties);

SourceGenerators\RazorSourceGenerator.RazorProviders.cs (1)

117relativePath = Encoding.UTF8.GetString(Convert.FromBase64String(encodedRelativePath));

CompilationOptionsReader.cs (1)

122? Encoding.UTF8

AbstractResxGenerator.cs (4)

252var errorText = SourceText.From(text, Encoding.UTF8, SourceHashAlgorithm.Sha256); 366OutputText = SourceText.From("", Encoding.UTF8); 392OutputText = SourceText.From(result, Encoding.UTF8, SourceHashAlgorithm.Sha256); 735OutputText = SourceText.From(result, Encoding.UTF8, SourceHashAlgorithm.Sha256);

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\StringTable.cs (1)

413text = Encoding.UTF8.GetString(bytes, utf8Bytes.Length);

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\SourceTextExtensions.cs (1)

38using (var writer = new StreamWriter(stream, Encoding.UTF8, 1024, true))

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\StringExtensions.cs (1)

15return Encoding.UTF8.GetByteCount(value) == value.Length;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectReader.cs (1)

47_reader = new BinaryReader(stream, Encoding.UTF8, leaveOpen);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectWriter.cs (1)

94_writer = new BinaryWriter(stream, Encoding.UTF8, leaveOpen);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\TextEncodingKind.cs (3)

45TextEncodingKind.EncodingUtf8_BOM => Encoding.UTF8, 82Debug.Assert(HasPreamble(Encoding.UTF8)); 83kind = (encoding.Equals(Encoding.UTF8) || HasPreamble(encoding)) ? TextEncodingKind.EncodingUtf8_BOM : TextEncodingKind.EncodingUtf8;

HelloWorldGenerator.cs (3)

36""", encoding: Encoding.UTF8)); 46""", encoding: Encoding.UTF8)); 57""", encoding: Encoding.UTF8));

Symbols\EmbeddedSymbols\EmbeddedSymbolManager.vb (1)

23Return VisualBasicSyntaxTree.ParseText(SourceText.From(text, Encoding.UTF8, SourceHashAlgorithms.Default))

Symbols\Source\SynthesizedMyGroupCollectionPropertyAccessorSymbol.vb (1)

74Dim tree = VisualBasicSyntaxTree.ParseText(SourceText.From(codeToParse, Encoding.UTF8, SourceHashAlgorithms.Default))

Syntax\SyntaxNodeFactories.vb (1)

288Return SourceText.From(text, Encoding.UTF8).GetSubText(offset)

Syntax\VisualBasicSyntaxTree.DummySyntaxTree.vb (1)

39Return Encoding.UTF8

Log\AnalyzerNameForTelemetry.cs (1)

16return Convert.ToBase64String(sha256.ComputeHash(Encoding.UTF8.GetBytes(name)));

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\StringTable.cs (1)

413text = Encoding.UTF8.GetString(bytes, utf8Bytes.Length);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectReader.cs (1)

47_reader = new BinaryReader(stream, Encoding.UTF8, leaveOpen);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectWriter.cs (1)

94_writer = new BinaryWriter(stream, Encoding.UTF8, leaveOpen);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\TextEncodingKind.cs (3)

45TextEncodingKind.EncodingUtf8_BOM => Encoding.UTF8, 82Debug.Assert(HasPreamble(Encoding.UTF8)); 83kind = (encoding.Equals(Encoding.UTF8) || HasPreamble(encoding)) ? TextEncodingKind.EncodingUtf8_BOM : TextEncodingKind.EncodingUtf8;

Workspace\Solution\TextLoader.cs (1)

161SourceText.From(string.Empty, Encoding.UTF8),

MSBuild\MSBuildWorkspace.cs (1)

510this.SaveDocumentText(info.Id, fullPath, text, text.Encoding ?? Encoding.UTF8);

AbstractBuildHost.cs (1)

188var stream = new MemoryStream(Encoding.UTF8.GetBytes(projectContent));

DataFrame.IO.cs (1)

584WrappedStreamReaderOrStringReader wrappedStreamReaderOrStringReader = new WrappedStreamReaderOrStringReader(csvStream, encoding ?? Encoding.UTF8);

DataFrameColumns\ArrowStringDataFrameColumn.cs (5)

262return Encoding.UTF8.GetString(data, bytes.Length); 541ret.Append(IsValid(i) ? GetBytes(i) : Encoding.UTF8.GetBytes(value)); 601ReadOnlySpan<byte> bytes = value != null ? Encoding.UTF8.GetBytes(value) : default(ReadOnlySpan<byte>); 642ReadOnlySpan<byte> bytes = value != null ? Encoding.UTF8.GetBytes(value) : default(ReadOnlySpan<byte>); 687Encoding encoding = Encoding.UTF8;

ArrowStringColumnTests.cs (1)

41byte[] bytes = Encoding.UTF8.GetBytes(data);

Contracts\DacStreams_1.cs (1)

117string name = Encoding.UTF8.GetString(miniMdBuffer.Slice((int)(currentAddress - miniMetaDataBuffAddress), stringLen));

EcmaMetadataUtils.cs (1)

83return Encoding.UTF8.GetString(buffer);

CdacGenerator.cs (3)

48SourceText.From(LayoutSetSource.Source, Encoding.UTF8)); 55SourceText.From(TypeNameResolverSource.Source, Encoding.UTF8)); 68spc.AddSource(Emitter.HintNameFor(model), SourceText.From(Emitter.Emit(model), Encoding.UTF8)));

OutputBufferHelpers.cs (2)

36int byteCount = Encoding.UTF8.GetByteCount(str); 44Encoding.UTF8.GetEncoder().Convert(str.AsSpan(), target, true, out _, out int bytesWritten, out _);

DiagnosticsIpc\IpcMessage.cs (1)

115using (BinaryReader reader = new(stream, Encoding.UTF8, true))

DiagnosticsIpc\IpcTransport.cs (1)

474string environ = Encoding.UTF8.GetString(environData);

Writer\SymUnmanagedWriterImpl.cs (3)

377byte[] bytes = Encoding.UTF8.GetBytes(value); 379value = Encoding.UTF8.GetString(bytes, 0, bytes.Length); 383encodedLength = Encoding.UTF8.GetByteCount(value);

src\DownloadFile.cs (1)

87var decodedToken = System.Text.Encoding.UTF8.GetString(encodedTokenBytes);

src\GenerateSourcePackageSourceLinkTargetsFile.cs (2)

38File.WriteAllText(OutputPath, GetOutputFileContent(), Encoding.UTF8); 110hash = BitConverter.ToString(hashAlg.ComputeHash(Encoding.UTF8.GetBytes(packageId)), 0, 20).Replace("-", "");

src\InstallDotNetCore.cs (1)

60var bytes = Encoding.UTF8.GetBytes(jsonContent);

src\ValidateLicense.cs (2)

38var actualLines = File.ReadAllLines(LicensePath, Encoding.UTF8); 39var expectedLines = File.ReadAllLines(ExpectedLicensePath, Encoding.UTF8);

src\GenerateGuidFromName.cs (1)

26var nameBytes = System.Text.Encoding.UTF8.GetBytes(Name ?? string.Empty);

src\RpmBuilder.cs (1)

405using StreamReader reader = new(file.DataStream, Encoding.UTF8, detectEncodingFromByteOrderMarks: true, bufferSize: -1, leaveOpen: true);

src\RpmHeader.cs (4)

164entries.Add(new Entry(entry.Tag, entry.Type, Encoding.UTF8.GetString(store, entry.Offset, length))); 178strings[i] = Encoding.UTF8.GetString(store, offset, length); 271byte[] bytes = Encoding.UTF8.GetBytes((string)entry.Value); 286byte[] bytes = Encoding.UTF8.GetBytes(str);

src\RpmLead.cs (2)

40lead.Name = Encoding.UTF8.GetString(name, 0, Array.IndexOf<byte>(name, 0)); 58Encoding.UTF8.GetBytes(Name, 0, Name.Length, name, 0);

GenerateNuSpec.cs (2)

138var oldSource = Encoding.UTF8.GetString(File.ReadAllBytes(OutputFileName)); 145newSource = Encoding.UTF8.GetString(stream.ToArray());

OptProf\GenerateTrainingInputFiles.cs (2)

50config = OptProfTrainingConfiguration.Deserialize(File.ReadAllText(ConfigurationFile, Encoding.UTF8)); 105using (var reader = new StreamReader(stream, Encoding.UTF8, detectEncodingFromByteOrderMarks: true, bufferSize: 2048, leaveOpen: true))

OptProf\GenerateTrainingPropsFile.cs (1)

61</Project>", Encoding.UTF8);

OptProf\GetRunSettingsSessionConfiguration.cs (2)

55var buildDropName = GetTestsDropName(File.ReadAllText(BootstrapperInfoPath, Encoding.UTF8)); 56var (testContainersString, testCaseFilterString) = GetTestContainersAndFilters(File.ReadAllText(ConfigurationFile, Encoding.UTF8), ConfigurationFile);

Vsix\FinalizeInsertionVsixFile.cs (2)

115using (var reader = new StreamReader(stream, Encoding.UTF8, detectEncodingFromByteOrderMarks: true, bufferSize: 2048, leaveOpen: true)) 128using (var writer = new StreamWriter(stream, Encoding.UTF8, bufferSize: 2048, leaveOpen: false))

Vsix\GetPkgDefAssemblyDependencyGuid.cs (1)

54fullHash = sha2.ComputeHash(Encoding.UTF8.GetBytes(value));

Utils.cs (2)

24byte[] bytes = Encoding.UTF8.GetBytes(value); 83StringReplace(fileName, tokenReplacements, Encoding.UTF8);

UILanguageOverride.cs (1)

17private static readonly Encoding s_defaultMultilingualEncoding = Encoding.UTF8;

Uuid.cs (1)

21var nameBytes = Encoding.UTF8.GetBytes(name ?? string.Empty);

DeltaProject.cs (1)

77updatedSolution = Solution.WithDocumentText (baseDocumentId, SourceText.From (contents, Encoding.UTF8));

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

381errorResponse = Encoding.UTF8.GetBytes(ex.GetMessageFromException());

src\sdk\src\Dotnet.Watch\HotReloadAgent.PipeRpc\StreamExtensions.cs (2)

86var bytes = Encoding.UTF8.GetBytes(value); 221return Encoding.UTF8.GetString(buffer, 0, size);

UI\PhysicalConsole.cs (1)

18Console.OutputEncoding = Encoding.UTF8;

src\sdk\src\Cli\Microsoft.DotNet.FileBasedPrograms\Sha256Hasher.cs (1)

19return Convert.ToHexStringLower(SHA256.HashData(Encoding.UTF8.GetBytes(text)));

src\sdk\src\Resolvers\Microsoft.NET.Sdk.WorkloadManifestReader\SdkDirectoryWorkloadManifestProvider.cs (1)

307byte[] bytes = sha256Hash.ComputeHash(Encoding.UTF8.GetBytes(string.Join(";",

src\sdk\src\Resolvers\Microsoft.NET.Sdk.WorkloadManifestReader\SdkDirectoryWorkloadManifestProvider.GlobalJsonReader.cs (1)

46using var memStream = new MemoryStream(Encoding.UTF8.GetBytes(content));

ChatCompletion\ChatResponse{T}.cs (2)

95var utf8ByteLength = Encoding.UTF8.GetByteCount(json); 99var utf8SpanLength = Encoding.UTF8.GetBytes(json, 0, json.Length, buffer, 0);

Common\OtelMessageSerializer.cs (1)

293return Encoding.UTF8.GetString(dc.Data.ToArray());

Contents\DataContent.cs (2)

375return $"MediaType = {MediaType}, Text = \"{Encoding.UTF8.GetString(Data.ToArray())}\""; 380return $"JSON = {Encoding.UTF8.GetString(Data.ToArray())}";

Contents\DataUriParser.cs (1)

205Encoding.UTF8.GetBytes(WebUtility.UrlDecode(Data.ToString()));

Contents\DataContentTests.cs (7)

124Assert.Equal(expectedData, Encoding.UTF8.GetString(content.Data.ToArray())); 319byte[] testData = Encoding.UTF8.GetBytes("{\"key\": \"value\"}"); 483byte[] testData = Encoding.UTF8.GetBytes("{}"); 510byte[] testData = Encoding.UTF8.GetBytes("{}"); 542byte[] testData = Encoding.UTF8.GetBytes("{}"); 571byte[] testData = Encoding.UTF8.GetBytes("{}"); 717byte[] testData = Encoding.UTF8.GetBytes("<html></html>");

Formats\Html\HtmlReportWriter.cs (1)

52using var writer = new StreamWriter(stream, Encoding.UTF8);

ResponseCacheTester.cs (2)

15private static readonly byte[] _responseA = Encoding.UTF8.GetBytes("Content A"); 17private static readonly byte[] _responseB = Encoding.UTF8.GetBytes("Content B");

PromptBasedFunctionCallingChatClient.cs (1)

108var reader = new Utf8JsonReader(Encoding.UTF8.GetBytes(toolCall));

VerbatimHttpHandler.cs (1)

57ByteArrayContent newContent = new(Encoding.UTF8.GetBytes(actualInput));

VerbatimMultiPartHttpHandler.cs (2)

80using var reader = new StreamReader(stream, Encoding.UTF8); 153return new() { Content = new StringContent(sentJsonOutput, Encoding.UTF8, "application/json") };

OpenAIAssistantsChatClient.cs (1)

207Inputs = [new DataContent(Encoding.UTF8.GetBytes(details.CodeInterpreterInput), OpenAIClientExtensions.PythonMediaType)],

OpenAIResponsesChatClient.cs (2)

258Inputs = !string.IsNullOrWhiteSpace(cicri.Code) ? [new DataContent(Encoding.UTF8.GetBytes(cicri.Code), OpenAIClientExtensions.PythonMediaType)] : null, 501Inputs = [new DataContent(Encoding.UTF8.GetBytes(codeInterpreterDeltaUpdate.Delta), OpenAIClientExtensions.PythonMediaType)],

OpenAIHostedFileClientIntegrationTests.cs (8)

33byte[] contentBytes = Encoding.UTF8.GetBytes(content); 59using var reader = new StreamReader(downloadStream, Encoding.UTF8); 202byte[] contentBytes = Encoding.UTF8.GetBytes(content); 212Assert.Equal(content, Encoding.UTF8.GetString(dataContent.Data.ToArray())); 231byte[] contentBytes = Encoding.UTF8.GetBytes(content); 298byte[] contentBytes = Encoding.UTF8.GetBytes(content2); 325using var reader = new StreamReader(downloadStream, Encoding.UTF8); 416using var uploadStream = new MemoryStream(Encoding.UTF8.GetBytes(csvContent));

OpenAIHostedFileClientTests.cs (10)

585""", Encoding.UTF8, "application/json") 619""", Encoding.UTF8, "application/json") 656""", Encoding.UTF8, "application/json") 681""", Encoding.UTF8, "application/json") 711""", Encoding.UTF8, "application/json") 738""", Encoding.UTF8, "application/json") 780""", Encoding.UTF8, "application/json") 804Content = new StringContent("{}", Encoding.UTF8, "application/json") 840""", Encoding.UTF8, "application/json") 865""", Encoding.UTF8, "application/json")

OpenAIResponseClientTests.cs (6)

3400Assert.Equal("# Calculating the sum of numbers from 1 to 5\nresult = sum(range(1, 6))\nresult", Encoding.UTF8.GetString(codeInput.Data.ToArray())); 3620Assert.Equal("# Calculate the sum of numbers from 1 to 10\nsum_of_numbers = sum(range(1, 11))\nsum_of_numbers", Encoding.UTF8.GetString(codeInput.Data.ToArray())); 3720codeBuilder.Append(Encoding.UTF8.GetString(dataContent.Data.ToArray())); 3746Assert.Equal("# sum(range(1, 11))", Encoding.UTF8.GetString(codeInput.Data.ToArray())); 5174var pdfData = Encoding.UTF8.GetBytes("pdfdata"); 7177return Encoding.UTF8.GetString(ms.ToArray());

DistributedCacheExtensions.cs (4)

75cache.Set(key, Encoding.UTF8.GetBytes(value), options); 107return cache.SetAsync(key, Encoding.UTF8.GetBytes(value), options, token); 123return Encoding.UTF8.GetString(data, 0, data.Length); 140return Encoding.UTF8.GetString(data, 0, data.Length);

Internal\InbuiltTypeSerializer.cs (4)

39return Encoding.UTF8.GetString(segment.Array, segment.Offset, segment.Count); 45string s = Encoding.UTF8.GetString(oversized, 0, length); 56int length = Encoding.UTF8.GetByteCount(value); 58int actual = Encoding.UTF8.GetBytes(value, 0, value.Length, oversized, 0);

SerializerTests.cs (1)

294return Encoding.UTF8.GetString(value.ToArray());

RedisCache.cs (1)

109_instancePrefix = (RedisKey)Encoding.UTF8.GetBytes(instanceName);

src\runtime\src\libraries\Common\src\SourceGenerators\SourceWriter.cs (1)

67return SourceText.From(_sb.ToString(), Encoding.UTF8);

MarkdownReader.cs (1)

47new(source, System.Text.Encoding.UTF8, detectEncodingFromByteOrderMarks: true, bufferSize: 1024, leaveOpen: true);

MarkItDownReader.cs (1)

56StandardOutputEncoding = Encoding.UTF8,

Readers\MarkdownReaderTests.cs (1)

204using MemoryStream stream = new(System.Text.Encoding.UTF8.GetBytes(content));

Readers\MarkItDownConditionHelper.cs (1)

27StandardOutputEncoding = Encoding.UTF8,

src\sdk\src\Dotnet.Watch\HotReloadAgent.PipeRpc\StreamExtensions.cs (2)

86var bytes = Encoding.UTF8.GetBytes(value); 221return Encoding.UTF8.GetString(buffer, 0, size);

GenerateEmbeddedResourcesManifest.cs (1)

40Encoding = Encoding.UTF8,

ServiceState.cs (2)

34_data = Encoding.UTF8.GetBytes(state); 42=> _data == null ? string.Empty : Encoding.UTF8.GetString(_data);

Logging\Internal\HttpRequestBodyReader.cs (1)

94return Encoding.UTF8.GetString(buffer, 0, read);

Logging\Internal\HttpResponseBodyReader.cs (1)

200_ = sb.Append(Encoding.UTF8.GetString(buffer.AsMemory(0, read).ToArray()));

Logging\AcceptanceTests.cs (3)

204return Encoding.UTF8.GetString(buffer); 256var responseString = Encoding.UTF8.GetString(buffer); 278responseString = Encoding.UTF8.GetString(buffer);

Logging\HttpClientLoggerTest.cs (19)

Logging\HttpClientLoggingExtensionsTest.cs (1)

338using var stream = new MemoryStream(Encoding.UTF8.GetBytes("""

Logging\HttpRequestBodyReaderTest.cs (6)

41Content = new StringContent(input, Encoding.UTF8, "text/plain"), 85Content = new StringContent(input, Encoding.UTF8, contentType), 106Content = new StringContent(input, Encoding.UTF8, "text/plain"), 134Content = new StringContent(input, Encoding.UTF8, "text/plain"), 158Content = new StringContent(input, Encoding.UTF8, "text/plain"), 232Content = new StringContent("content", Encoding.UTF8, "text/plain"),

Logging\HttpRequestReaderTest.cs (17)

Logging\HttpResponseBodyReaderTest.cs (7)

50Content = new StringContent(expectedContentBody, Encoding.UTF8, TextPlain) 86Content = new StringContent(string.Empty, Encoding.UTF8, TextPlain) 111Content = new StringContent(expectedContentBody, Encoding.UTF8, contentType) 131Content = new StringContent(input, Encoding.UTF8, TextPlain) 155Content = new StreamContent(new NotSeekableStream(new(Encoding.UTF8.GetBytes(bigContent)))) 182Content = new StreamContent(new NotSeekableStream(new(Encoding.UTF8.GetBytes(bigContent)))) 291var memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(content));

Resilience\RequestMessageSnapshotTests.cs (1)

60Content = new StringContent("{\"name\":\"John Doe\",\"age\":33}", Encoding.UTF8, "application/json")

JsonConsoleFormatter.cs (2)

105var logMessageBuffer = ArrayPool<char>.Shared.Rent(Encoding.UTF8.GetMaxCharCount(messageBytes.Length)); 108var charsWritten = Encoding.UTF8.GetChars(messageBytes, logMessageBuffer);

EventSourceLogger.cs (2)

293? Encoding.UTF8.GetString(buffer.Array!, buffer.Offset, buffer.Count) 294: Encoding.UTF8.GetString(stream.ToArray());

LoggerMessageGenerator.Roslyn4.0.cs (1)

213context.AddSource("LoggerMessage.g.cs", SourceText.From(result, Encoding.UTF8));

Generator.cs (1)

56context.AddSource("Validators.g.cs", SourceText.From(result, Encoding.UTF8));

Resolver\LoopbackDnsServer.cs (1)

228var encodedLabels = name.Split('.', StringSplitOptions.RemoveEmptyEntries).Select(label => (ReadOnlyMemory<byte>)Encoding.UTF8.GetBytes(s_idnMapping.GetAscii(label)))

Fuzzers\WriteDomainNameRoundTripFuzzer.cs (1)

20string domainName = Encoding.UTF8.GetString(data);

Latency\Internal\LatencyConsoleExporterTests.cs (1)

160public override Encoding Encoding => Encoding.UTF8;

Emitters\ValidationsGenerator.Emitter.cs (1)

27context.AddSource("ValidatableInfoResolver.g.cs", SourceText.From(source, Encoding.UTF8));

Emitters\ValidationsGenerator.InfoClasses.Emitter.cs (1)

50using var reader = new StreamReader(stream, Encoding.UTF8);

BuildMetadataGenerator.cs (1)

55context.AddSource("BuildMetadataExtensions.g.cs", SourceText.From(result, Encoding.UTF8));

ComplianceReportsGenerator.cs (1)

112File.WriteAllText(Path.Combine(_directory, _fileName), report, Encoding.UTF8);

LoggingGenerator.cs (1)

49context.AddSource("Logging.g.cs", SourceText.From(result, Encoding.UTF8));

ComplianceReportsGenerator.cs (1)

112File.WriteAllText(Path.Combine(_directory, _fileName), report, Encoding.UTF8);

MetadataReportsGenerator.cs (1)

110File.WriteAllText(Path.Combine(path, _fileName), reportStringBuilder.ToString(), Encoding.UTF8);

MetricsReportsGenerator.cs (1)

86File.WriteAllText(Path.Combine(path, _fileName), report, Encoding.UTF8);

MetricsGenerator.cs (2)

41context.AddSource("Factory.g.cs", SourceText.From(factory, Encoding.UTF8)); 45context.AddSource("Metrics.g.cs", SourceText.From(metrics, Encoding.UTF8));

MetricsReportsGenerator.cs (1)

86File.WriteAllText(Path.Combine(path, _fileName), report, Encoding.UTF8);

Infrastructure\DotNetDispatcher.cs (3)

222var count = Encoding.UTF8.GetByteCount(arguments); 226var receivedBytes = Encoding.UTF8.GetBytes(arguments, buffer); 308var utf8JsonBytes = Encoding.UTF8.GetBytes(arguments);

Handlers\HybridWebView\HybridWebViewHandler.cs (1)

193 var contentBytes = Encoding.UTF8.GetBytes(json);

Services\Crc64HashAlgorithm.cs (1)

198 byte[] bytes = ComputeHash(Encoding.UTF8.GetBytes(input));

Internals\ImageParser.cs (1)

476 string identifier = global::System.Text.Encoding.UTF8.GetString(buffer, 0, NetscapeApplicationExtensionID.Length);

CodeBehindGenerator.cs (3)

295 context.AddSource(hintName, SourceText.From(sb.ToString(), Encoding.UTF8)); 377 context.AddSource(hintName, SourceText.From(sb.ToString(), Encoding.UTF8)); 640 sourceProductionContext.AddSource(hintName, SourceText.From(sb.ToString(), Encoding.UTF8));

src\Core\src\Services\Crc64HashAlgorithm.cs (1)

198 byte[] bytes = ComputeHash(Encoding.UTF8.GetBytes(input));

Text\XmlAttributedTextReader.cs (1)

99 string text = Encoding.UTF8.GetString(bytes, 0, bytes.Length);

Text\XmlAttributedTextWriter.cs (1)

32 byte[] bytes = Encoding.UTF8.GetBytes(attributedText.Text);

EstimatorTypeGenerator.cs (1)

53context.AddSource(className + ".cs", SourceText.From(code.TransformText(), Encoding.UTF8));

SweepableEstimatorFactoryGenerator.cs (1)

48context.AddSource(className + ".cs", SourceText.From(code.TransformText(), Encoding.UTF8));

SweepableEstimatorGenerator.cs (1)

73context.AddSource(c.Item1 + ".cs", SourceText.From(c.Item2, Encoding.UTF8));

TextFileSampleTests.cs (1)

28var eol = Encoding.UTF8.GetBytes("\r\n");

Data\ModelLoadContext.cs (1)

87Reader = new BinaryReader(ent.Stream, Encoding.UTF8, leaveOpen: true);

Data\ModelLoading.cs (2)

194using (var reader = new BinaryReader(stream, Encoding.UTF8, leaveOpen: true)) 337using (var reader = new BinaryReader(ent.Stream, Encoding.UTF8, leaveOpen: true))

Data\ModelSaveContext.cs (2)

100Writer = new BinaryWriter(_ent.Stream, Encoding.UTF8, leaveOpen: true); 180using (var writer = new BinaryWriter(ent.Stream, Encoding.UTF8, leaveOpen: true))

Data\ModelSaving.cs (1)

50using (var writer = new BinaryWriter(ent.Stream, Encoding.UTF8, leaveOpen: true))

Utilities\TextReaderStream.cs (2)

58/// Create a stream wrapping the given text reader, using the <see cref="Encoding.UTF8"/> 63: this(baseReader, Encoding.UTF8)

Commands\SavePredictorCommand.cs (1)

153using (var writer = new BinaryWriter(binaryModelStream, Encoding.UTF8, true))

DataLoadSave\Binary\BinaryLoader.cs (2)

778_reader = new BinaryReader(_stream, Encoding.UTF8, leaveOpen); 868_reader = new BinaryReader(_stream, Encoding.UTF8, leaveOpen: false);

DataLoadSave\Binary\BinarySaver.cs (3)

326int stringLen = Encoding.UTF8.GetByteCount(metadataInfos[i].Item1); 470using (BinaryWriter writer = new BinaryWriter(stream, Encoding.UTF8, leaveOpen: true)) 517int nameLen = Encoding.UTF8.GetByteCount(name);

DataLoadSave\Binary\CodecFactory.cs (2)

43_encoding = Encoding.UTF8; 159using (BinaryReader reader = new BinaryReader(definitionStream, Encoding.UTF8, true))

DataLoadSave\Transpose\TransposeSaver.cs (1)

156using (var writer = new BinaryWriter(stream, Encoding.UTF8, leaveOpen: true))

OnnxUtils.cs (4)

262private static ByteString StringToByteString(ReadOnlyMemory<char> str) => ByteString.CopyFrom(Encoding.UTF8.GetBytes(str.ToString())); 264=> str.Select(s => ByteString.CopyFrom(Encoding.UTF8.GetBytes(s.ToString()))); 267=> str.Select(s => ByteString.CopyFrom(Encoding.UTF8.GetBytes(s))); 269private static ByteString StringToByteString(string str) => ByteString.CopyFrom(Encoding.UTF8.GetBytes(str));

OnnxTransform.cs (1)

600dstEditor.Values[i] = slotsAttr.Strings[i].ToString(Encoding.UTF8).AsMemory();

BytesStreamSource.cs (1)

28: this(Encoding.UTF8.GetBytes(data))

Model\BPETokenizer.cs (3)

1323int destinationMaxSize = Encoding.UTF8.GetMaxByteCount(text.Length); 1436int destinationMaxSize = Encoding.UTF8.GetMaxByteCount(text.Length); 1516int destinationMaxSize = Encoding.UTF8.GetMaxByteCount(text.Length);

Model\CodeGenTokenizer.cs (5)

452int destinationMaxSize = Encoding.UTF8.GetMaxByteCount(textSpan.Length); 1135int destinationMaxSize = Encoding.UTF8.GetMaxByteCount(textSpan.Length); 1199int destinationMaxSize = Encoding.UTF8.GetMaxByteCount(textSpan.Length); 1291int bytesCountToEncode = Encoding.UTF8.GetMaxByteCount(specialToken.Length); 1313string result = Encoding.UTF8.GetString(bytes, 0, bytesIndex);

Model\SentencePieceBaseModel.cs (2)

324int len = Encoding.UTF8.GetMaxCharCount(bytesCount); 662int len = Encoding.UTF8.GetMaxCharCount(bytesCount);

Model\SentencePieceBpeModel.cs (4)

228int len = Encoding.UTF8.GetMaxByteCount(text.Length - i); 528int len = Encoding.UTF8.GetMaxByteCount(text.Length - i); 791int len = Encoding.UTF8.GetMaxByteCount(text.Length - i); 1067int len = Encoding.UTF8.GetMaxByteCount(text.Length - i);

Model\SentencePieceUnigramModel.cs (2)

471if (Encoding.UTF8.GetMaxCharCount(normalizationSpan.Length) > normalizedUtf16Span.Length) 569Debug.Assert(Encoding.UTF8.GetMaxByteCount(text.Length) * 3 <= buffer.Length * sizeof(int));

Model\TiktokenTokenizer.cs (7)

143_decoder![specialToken.Value] = Encoding.UTF8.GetBytes(specialToken.Key); 243string decodedToken = Encoding.UTF8.GetString(tokenBytes); 323int utf8Length = Encoding.UTF8.GetMaxByteCount(text.Length); 440int utf8Length = Encoding.UTF8.GetMaxByteCount(text.Length); 605int utf8Length = Encoding.UTF8.GetMaxByteCount(text.Length); 731int utf8Length = Encoding.UTF8.GetMaxByteCount(text.Length); 899if (Encoding.UTF8.GetMaxCharCount(utf8BytesIncompleteCount + tokenBytes.Length) > tempBuffer.Length)

Normalizer\SentencePieceNormalizer.cs (4)

116byte[] inputArray = ArrayPool<byte>.Shared.Rent(Encoding.UTF8.GetMaxByteCount(text.Length)); 117byte[]? poolArray = ArrayPool<byte>.Shared.Rent(Math.Max(64, Encoding.UTF8.GetMaxByteCount(text.Length) * 2)); 123return length == 0 ? string.Empty : Encoding.UTF8.GetString(poolArray!, 0, length); 401byte[] chainedBytes = ArrayPool<byte>.Shared.Rent(Encoding.UTF8.GetMaxByteCount(chained.Length));

SentencepieceModel.cs (1)

80string result = Encoding.UTF8.GetString(data, pos, length);

Utils\DoubleArrayTrie.cs (1)

746int encodingLength = Encoding.UTF8.GetByteCount(pair.Key);

Utils\Helpers.cs (2)

70Debug.Assert(Encoding.UTF8.GetMaxByteCount(text.Length) <= destination.Length); 162Debug.Assert(Encoding.UTF8.GetMaxByteCount(text.Length) <= destination.Length);

Utils\Helpers.netcoreapp.cs (4)

56=> Encoding.UTF8.GetBytes(source, destination); 59=> Encoding.UTF8.TryGetBytes(source, destination, out bytesWritten); 62=> Encoding.UTF8.GetString(utf8Bytes); 65=> Encoding.UTF8.GetChars(bytes, chars);

Utils\OrdinalUtf8StringComparer.cs (2)

58int requiredLength1 = Encoding.UTF8.GetMaxByteCount(xLen); 59int requiredLength2 = Encoding.UTF8.GetMaxByteCount(yLen);

BpeTests.cs (2)

592File.WriteAllText(fileName, JsonSerializer.Serialize<Dictionary<string, int>>(dic), Encoding.UTF8); 952using var reader = new StreamReader(jsonModelStream, Encoding.UTF8);

DoubleArrayTrieTest.cs (2)

79byte[] utf8Bytes = Encoding.UTF8.GetBytes(key); 94byte[] utf8Bytes = Encoding.UTF8.GetBytes(key);

SentencePieceTests.cs (1)

873byte[] bytes = Encoding.UTF8.GetBytes(value);

src\Microsoft.ML.Tokenizers\Utils\DoubleArrayTrie.cs (1)

746int encodingLength = Encoding.UTF8.GetByteCount(pair.Key);

src\Microsoft.ML.Tokenizers\Utils\Helpers.cs (2)

70Debug.Assert(Encoding.UTF8.GetMaxByteCount(text.Length) <= destination.Length); 162Debug.Assert(Encoding.UTF8.GetMaxByteCount(text.Length) <= destination.Length);

src\Microsoft.ML.Tokenizers\Utils\Helpers.netcoreapp.cs (4)

56=> Encoding.UTF8.GetBytes(source, destination); 59=> Encoding.UTF8.TryGetBytes(source, destination, out bytesWritten); 62=> Encoding.UTF8.GetString(utf8Bytes); 65=> Encoding.UTF8.GetChars(bytes, chars);

src\Microsoft.ML.Tokenizers\Utils\OrdinalUtf8StringComparer.cs (2)

58int requiredLength1 = Encoding.UTF8.GetMaxByteCount(xLen); 59int requiredLength2 = Encoding.UTF8.GetMaxByteCount(yLen);

UnigramTests.cs (41)

DigestUtils.cs (1)

112SHA256.HashData(Encoding.UTF8.GetBytes(content), hash);

ImageBuilder.cs (1)

67long imageSize = Encoding.UTF8.GetBytes(imageJsonStr).Length;

LocalDaemons\ContainerArchive.cs (7)

140using MemoryStream configStream = new(Encoding.UTF8.GetBytes(image.Config)); 174using MemoryStream manifestStream = new(Encoding.UTF8.GetBytes(manifestNode.ToJsonString())); 189using MemoryStream layoutStream = new(Encoding.UTF8.GetBytes("{\"imageLayoutVersion\": \"1.0.0\"}")); 205using MemoryStream manifestStream = new(Encoding.UTF8.GetBytes(image.Manifest)); 236using MemoryStream indexStream = new(Encoding.UTF8.GetBytes(indexJson)); 276using (MemoryStream manifestListStream = new(Encoding.UTF8.GetBytes(multiArchImage.ImageIndex))) 296using MemoryStream indexStream = new(Encoding.UTF8.GetBytes(indexJson));

LocalDaemons\DockerCli.cs (7)

368using (MemoryStream configStream = new(Encoding.UTF8.GetBytes(image.Config))) 399using (MemoryStream manifestStream = new(Encoding.UTF8.GetBytes(manifestNode.ToJsonString()))) 437using (MemoryStream ociLayoutStream = new MemoryStream(Encoding.UTF8.GetBytes(ociLayoutContent))) 455using (MemoryStream manifestStream = new MemoryStream(Encoding.UTF8.GetBytes(image.Manifest))) 480using (MemoryStream indexStream = new(Encoding.UTF8.GetBytes(indexJson))) 543using (MemoryStream indexStream = new(Encoding.UTF8.GetBytes(multiArchImage.ImageIndex))) 562using (MemoryStream indexStream = new(Encoding.UTF8.GetBytes(indexJson)))

Registry\Registry.cs (1)

663using (MemoryStream stringStream = new(Encoding.UTF8.GetBytes(builtImage.Config)))

AllowEmptyTelemetry.cs (1)

69var utf8UpperBytes = Encoding.UTF8.GetBytes(text.ToUpperInvariant());

NugetContentAssetPreprocessor.cs (1)

65using (var streamWriter = new StreamWriter(stream, Encoding.UTF8, bufferSize: 4096, leaveOpen: true))

ResolvePackageAssets.cs (1)

340private static readonly Encoding TextEncoding = Encoding.UTF8;

src\sdk\src\Resolvers\Microsoft.NET.Sdk.WorkloadManifestReader\SdkDirectoryWorkloadManifestProvider.cs (1)

307byte[] bytes = sha256Hash.ComputeHash(Encoding.UTF8.GetBytes(string.Join(";",

src\sdk\src\Resolvers\Microsoft.NET.Sdk.WorkloadManifestReader\SdkDirectoryWorkloadManifestProvider.GlobalJsonReader.cs (1)

46using var memStream = new MemoryStream(Encoding.UTF8.GetBytes(content));

AppHost\HostWriter.cs (4)

22private static readonly byte[] AppBinaryPathPlaceholderSearchValue = Encoding.UTF8.GetBytes(AppBinaryPathPlaceholder); 31private static readonly byte[] DotNetSearchPlaceholderSearchValue = Encoding.UTF8.GetBytes(DotNetSearchPlaceholder); 75byte[] appPathBytes = Encoding.UTF8.GetBytes(appBinaryFilePath); 205? Encoding.UTF8.GetBytes(searchOptions.AppRelativeDotNet)

Bundle\Bundler.cs (2)

375using (BinaryWriter writer = new BinaryWriter(bundleStream, Encoding.UTF8, leaveOpen: true)) 540uint stringLength = (uint)Encoding.UTF8.GetByteCount(str); // BundleID with prefixed length

ComHost\ComHost.cs (1)

40byte[] clsidMapBytes = Encoding.UTF8.GetBytes(clsidMap);

MachO\BinaryFormat\Blobs\CodeDirectoryBlob.cs (3)

36string identifier = Encoding.UTF8.GetString(data, identifierDataOffset, nullTerminatorIndex); 294return (uint)(Encoding.UTF8.GetByteCount(identifier) + 1); 307var identifierBytes = Encoding.UTF8.GetBytes(_identifier);

src\runtime\src\coreclr\tools\Common\MachO\BinaryFormat\NameBuffer.cs (1)

55return System.Text.Encoding.UTF8.GetString(bytePtr, length);

ContentDispositionHeaderValue.cs (3)

546Base64.GetMaxEncodedToUtf8Length(Encoding.UTF8.GetByteCount(input.AsSpan())) + 556var contentLength = Encoding.UTF8.GetBytes(input.AsSpan(), bufferContent); 562var result = Encoding.UTF8.GetString(buffer.Slice(0, MimePrefix.Length + base64ContentLength + MimeSuffix.Length));

BrotliCompress.cs (1)

124var bytes = Encoding.UTF8.GetBytes(relativePath);

GenerateBlazorBootExtensionJson.cs (1)

42using var writer = JsonReaderWriterFactory.CreateJsonWriter(output, Encoding.UTF8, ownsStream: false, indent: true);

GenerateBlazorWebAssemblyBootJson50.cs (1)

165using var writer = JsonReaderWriterFactory.CreateJsonWriter(output, Encoding.UTF8, ownsStream: false, indent: true);

GenerateServiceWorkerAssetsManifest.cs (3)

72var bytes = sha.ComputeHash(Encoding.UTF8.GetBytes(combinedHash)); 82using var streamWriter = new StreamWriter(stream, Encoding.UTF8, bufferSize: 50, leaveOpen: true); 86using var jsonWriter = JsonReaderWriterFactory.CreateJsonWriter(stream, Encoding.UTF8, ownsStream: false, indent: true);

src\sdk\src\StaticWebAssetsSdk\Tasks\Utils\FileHasher.cs (2)

18var bytes = Encoding.UTF8.GetBytes(filePath); 26var bytes = Encoding.UTF8.GetBytes(relativePath);

Kudu\KuduConnect.cs (1)

37return Convert.ToBase64String(Encoding.UTF8.GetBytes(authInfo));

Tasks\Http\HttpClientExtensions.cs (1)

274var reader = new StreamReader(stream, Encoding.UTF8);

Tasks\MsDeploy\CreateManifestFile.cs (1)

83Utility.SaveDocument(document, outputFileName, Encoding.UTF8);

Tasks\MsDeploy\CreateParameterFile.cs (2)

224Utility.SaveDocument(document, outputFileName, Encoding.UTF8); 263Utility.SaveDocument(document, outputFileName, Encoding.UTF8);

Tasks\OneDeploy\OneDeploy.cs (1)

221publishUri, username, password, DefaultRequestContentType, userAgent, Encoding.UTF8, fileToPublishStream);

Tasks\OneDeploy\OneDeploy.WebJob.cs (1)

39publishUri, username, password, DefaultRequestContentType, userAgent, Path.GetFileName(fileToPublish), Encoding.UTF8, fileToPublishStream, cancellationToken);

Tasks\ZipDeploy\ZipDeploy.cs (1)

94IHttpResponse? response = await client.PostRequestAsync(uri, userName, password, "application/zip", userAgent, Encoding.UTF8, stream);

Tasks\ZipDeploy\ZipDeploymentStatus.cs (1)

92var reader = new StreamReader(stream, Encoding.UTF8);

EncodeRazorInputItem.cs (1)

36var targetPath = Convert.ToBase64String(Encoding.UTF8.GetBytes(input.GetMetadata("TargetPath")));

src\sdk\src\RazorSdk\Tool\PipeName.cs (1)

51var bytes = sha.ComputeHash(Encoding.UTF8.GetBytes(baseDirectory));

src\sdk\src\RazorSdk\Tool\ServerProtocol\ServerLogger.cs (1)

116var bytes = Encoding.UTF8.GetBytes(output);

GeneratePackageAssetsTargetsFile.cs (1)

47Encoding = Encoding.UTF8,

GenerateStaticWebAssetEndpointsPropsFile.cs (1)

72Encoding = Encoding.UTF8,

GenerateStaticWebAssetsPropsFile.cs (1)

138Encoding = Encoding.UTF8,

Legacy\GenerateStaticWebAssetsPropsFile50.cs (1)

87Encoding = Encoding.UTF8,

Legacy\GenerateV1StaticWebAssetsManifest.cs (1)

47Encoding = Encoding.UTF8,

OverrideHtmlAssetPlaceholders.cs (1)

96this.PersistFileIfChanged(Encoding.UTF8.GetBytes(outputContent), outputPath);

ScopedCss\ComputeCssScope.cs (1)

46var bytes = Encoding.UTF8.GetBytes(relativePath + targetName);

ServiceWorker\GenerateServiceWorkerAssetsManifest.cs (2)

84var data = Encoding.UTF8.GetBytes(combinedHash); 123var data = Encoding.UTF8.GetBytes(contents);

StaticWebAssetsGeneratePackagePropsFile.cs (1)

42Encoding = Encoding.UTF8,

Utils\FileHasher.cs (2)

18var bytes = Encoding.UTF8.GetBytes(filePath); 26var bytes = Encoding.UTF8.GetBytes(relativePath);

Utils\HashingUtils.cs (1)

73return new(memoryStream, encoding: Encoding.UTF8, leaveOpen: true);

SdkDirectoryWorkloadManifestProvider.cs (1)

307byte[] bytes = sha256Hash.ComputeHash(Encoding.UTF8.GetBytes(string.Join(";",

SdkDirectoryWorkloadManifestProvider.GlobalJsonReader.cs (1)

46using var memStream = new MemoryStream(Encoding.UTF8.GetBytes(content));

System\Private\Windows\BinaryFormat\Support\BinaryFormatWriterScope.cs (1)

15Writer = new BinaryWriter(stream, Encoding.UTF8, leaveOpen: true);

System\Private\Windows\Ole\Composition.ManagedToNativeAdapter.cs (2)

415int byteCount = Encoding.UTF8.GetByteCount(value); 425byteCount = Encoding.UTF8.GetBytes(value, span);

System\Private\Windows\Ole\Composition.NativeToManagedAdapter.cs (1)

301return Encoding.UTF8.GetString(bytes);

JExtensions.cs (1)

220using var textReader = new StreamReader(fileStream, Encoding.UTF8, true);

Expressions\Cpp\CppStyleEvaluatorDefinition.cs (1)

24using MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(text));

Expressions\Shared\SharedEvaluatorDefinition.cs (2)

59using MemoryStream ms = new(Encoding.UTF8.GetBytes(text)); 85using MemoryStream ms = new(Encoding.UTF8.GetBytes(text));

Util\EncodingUtil.cs (3)

20return Encoding.UTF8; 46return Encoding.UTF8; 69return Encoding.UTF8;

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

442using TextReader tr = new StreamReader(s, System.Text.Encoding.UTF8, true); 451using var textReader = new StreamReader(fileStream, System.Text.Encoding.UTF8, true);

ConfigModel\TemplateConfigModel.cs (1)

410using TextReader tr = new StreamReader(content, System.Text.Encoding.UTF8, true);

FileRenameGenerator.cs (2)

90using MemoryStream source = new(Encoding.UTF8.GetBytes(sourceFilename)); 94return Encoding.UTF8.GetString(target.ToArray());

RunnableProjectConfig.cs (1)

274using TextReader reader = new StreamReader(excludeList, Encoding.UTF8, true, 4096, true);

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

442using TextReader tr = new StreamReader(s, System.Text.Encoding.UTF8, true); 451using var textReader = new StreamReader(fileStream, System.Text.Encoding.UTF8, true);

InMemoryFileSystem.cs (2)

525using StreamReader r = new(s, Encoding.UTF8, true, 8192, true); 545using StreamWriter r = new(s, Encoding.UTF8, 8192, true);

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

442using TextReader tr = new StreamReader(s, System.Text.Encoding.UTF8, true); 451using var textReader = new StreamReader(fileStream, System.Text.Encoding.UTF8, true);

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

442using TextReader tr = new StreamReader(s, System.Text.Encoding.UTF8, true); 451using var textReader = new StreamReader(fileStream, System.Text.Encoding.UTF8, true);

Tasks\VSTestTask2.cs (2)

46protected override Encoding StandardErrorEncoding => _disableUtf8ConsoleEncoding ? base.StandardErrorEncoding : Encoding.UTF8; 47protected override Encoding StandardOutputEncoding => _disableUtf8ConsoleEncoding ? base.StandardOutputEncoding : Encoding.UTF8;

LengthPrefixCommunicationChannel.cs (2)

33_reader = new BinaryReader(stream, Encoding.UTF8, true); 36_writer = new BinaryWriter(new PlatformStream().CreateBufferedStream(stream, SocketConstants.BufferSize), Encoding.UTF8, true);

BlameCollector.cs (1)

588Array.Copy(hashedLockName.ComputeHash(Encoding.UTF8.GetBytes(dumpFileNameFullPath)), toGuid, 16);

Microsoft\VisualBasic\FileIO\FileSystem.vb (3)

300Return OpenTextFileReader(file, Encoding.UTF8) 322Return OpenTextFileWriter(file, append, Encoding.UTF8) 773WriteAllText(file, text, append, Encoding.UTF8)

Microsoft\VisualBasic\Logging\FileLogTraceListener.vb (1)

50Private _encoding As Encoding = Encoding.UTF8

XmlFileInfoDocument.cs (1)

111encoding = Encoding.UTF8;

Mono.Cecil.Cil\PortablePdb.cs (2)

381 buffer.WriteBytes (System.Text.Encoding.UTF8.GetBytes (fileName)); 402 buffer.WriteBytes (System.Text.Encoding.UTF8.GetBytes ("SHA256"));

Mono.Cecil.Metadata\Buffers.cs (2)

376 string_offsets [index] = (uint) (position - (Encoding.UTF8.GetByteCount (entry.Key) + 1)); 402 WriteBytes (Encoding.UTF8.GetBytes (@string));

Mono.Cecil.Metadata\StringHeap.cs (1)

57 return Encoding.UTF8.GetString (data, start, length);

Mono.Cecil\AssemblyReader.cs (3)

3055 return ReadStringBlob (signature, Encoding.UTF8); 3230 infos.Add (new SourceLinkDebugInformation (Encoding.UTF8.GetString (ReadBlob (rows [i].Col2)))); 3810 var @string = Encoding.UTF8.GetString (buffer, position, length);

Mono.Cecil\AssemblyWriter.cs (3)

2516 signature.WriteBytes (Encoding.UTF8.GetBytes (source_link.content)); 2608 return GetBlobIndex (Encoding.UTF8.GetBytes (s)); 2725 var bytes = Encoding.UTF8.GetBytes (@string);

Microsoft.Cci.Pdb\BitAccess.cs (3)

186value = Encoding.UTF8.GetString(buffer, offset, len); 191var result = Encoding.UTF8.GetString(buffer, offset, len); 201value = Encoding.UTF8.GetString(buffer, offset, len);

XMake.cs (2)

2310Console.OutputEncoding = Encoding.UTF8; 2312Console.InputEncoding = Encoding.UTF8;

CoordinatorServer.Connection.cs (2)

41_reader = new BinaryReader(pipeStream, Encoding.UTF8, leaveOpen: true); 42_writer = new BinaryWriter(pipeStream, Encoding.UTF8, leaveOpen: true);

GetPackOutputItemsTask.cs (1)

95var nuspecReader = new NuspecReader(new MemoryStream(Encoding.UTF8.GetBytes(preprocessed)));

Utility\EncryptionUtility.cs (3)

13private static readonly byte[] _entropyBytes = Encoding.UTF8.GetBytes("NuGet"); 22var decryptedByteArray = Encoding.UTF8.GetBytes(value); 37return Encoding.UTF8.GetString(decryptedByteArray);

PluginCredentialProvider.cs (2)

204StandardOutputEncoding = Encoding.UTF8, 205StandardErrorEncoding = Encoding.UTF8,

Projects\ProjectJsonNuGetProject.cs (1)

351using (var writer = new StreamWriter(outputPath, false, Encoding.UTF8))

Utility\StreamUtility.cs (1)

19return StreamFromString(content, Encoding.UTF8);

PackageCreation\Authoring\PackageBuilder.cs (1)

1264var data = System.Text.Encoding.UTF8.GetBytes(path);

Signing\DerEncoding\DerEncoder.cs (1)

543byte[] encodedBytes = System.Text.Encoding.UTF8.GetBytes(chars, offset, count);

Signing\DerEncoding\DerSequenceReader.cs (1)

339string str = System.Text.Encoding.UTF8.GetString(_data, _position, contentLength);

DependencyGraphSpec.cs (2)

44private static readonly byte[] RestorePropertyName = Encoding.UTF8.GetBytes("restore"); 45private static readonly byte[] ProjectsPropertyName = Encoding.UTF8.GetBytes("projects");

JsonPackageSpecReader.cs (1)

35using (var ms = new MemoryStream(Encoding.UTF8.GetBytes(json)))

JsonPackageSpecReader.Utf8JsonStreamReader.cs (75)

LockFile\LockFileFormat.cs (1)

75byte[] byteArray = Encoding.UTF8.GetBytes(lockFileContent);

LockFile\Utf8JsonStreamIAssetsLogMessageConverter.cs (11)

LockFile\Utf8JsonStreamLockFileConverter.cs (8)

LockFile\Utf8JsonStreamLockFileLibraryConverter.cs (7)

33private static readonly byte[] Sha512PropertyName = Encoding.UTF8.GetBytes("sha512"); 34private static readonly byte[] TypePropertyName = Encoding.UTF8.GetBytes("type"); 35private static readonly byte[] PathPropertyName = Encoding.UTF8.GetBytes("path"); 36private static readonly byte[] MsbuildProjectPropertyName = Encoding.UTF8.GetBytes("msbuildProject"); 37private static readonly byte[] ServicablePropertyName = Encoding.UTF8.GetBytes("servicable"); 38private static readonly byte[] HasToolsPropertyName = Encoding.UTF8.GetBytes("hasTools"); 39private static readonly byte[] FilesPropertyName = Encoding.UTF8.GetBytes("files");

LockFile\Utf8JsonStreamLockFileTargetLibraryConverter.cs (16)

src\nuget-client\build\Shared\Utf8JsonStreamReader.cs (1)

288Encoding.UTF8.GetString(propertyName),

Converters\Utf8JsonReaderExtensions.cs (2)

26? Encoding.UTF8.GetString(reader.ValueSequence.ToArray()) 27: Encoding.UTF8.GetString(reader.ValueSpan.ToArray()),

HttpSource\HttpStreamValidation.cs (1)

81encoding: Encoding.UTF8,

Utility\CachingUtility.cs (1)

31hash = sha.ComputeHash(Encoding.UTF8.GetBytes(value));

Microsoft\Build\Tasks\Windows\UpdateManifestForBrowserApplication.cs (1)

111manifestWriter = new XmlTextWriter(appManifestFile, System.Text.Encoding.UTF8)

MS\Internal\WindowsRuntime\Generated\WinRT\GuidGenerator.cs (1)

137var data = wrt_pinterface_namespace.ToByteArray().Concat(UTF8Encoding.UTF8.GetBytes(sig)).ToArray();

System\Windows\Controls\DataGridClipboardHelper.cs (1)

80byte[] destinationBytes = InternalEncoding.Convert(Encoding.Unicode, Encoding.UTF8, sourceBytes);

System\Windows\Documents\FixedSchema.cs (1)

43!encoding.Equals(Encoding.UTF8.WebName, StringComparison.OrdinalIgnoreCase))

AlphaFlattener\Flattener.cs (1)

457XmlTextWriter writer = new System.Xml.XmlTextWriter(stream, System.Text.Encoding.UTF8)

Packaging\PartEditor.cs (1)

251_xmlWriter = new XmlTextWriter(stream, System.Text.Encoding.UTF8);

Packaging\XpsFixedDocumentReaderWriter.cs (1)

1122using (XmlTextWriter writer = new XmlTextWriter(stream, System.Text.Encoding.UTF8))

PrintConfig\PrintCapabilitesWriter.cs (2)

31Encoding = Encoding.UTF8, 37this._writer = XmlWriter.Create(new StreamWriter(stream, Encoding.UTF8), settings);

PrintConfig\PrtTicket_Public_Simple.cs (1)

1403return System.Text.Encoding.UTF8.GetString(ms.ToArray());

Serialization\Manager\XpsOMPackagingPolicy.cs (1)

252_currentFixedPageXmlWriter = new XmlTextWriter(_currentFixedPagePrintStream, Encoding.UTF8);

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\StringTable.cs (1)

413text = Encoding.UTF8.GetString(bytes, utf8Bytes.Length);

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\SourceTextExtensions.cs (1)

38using (var writer = new StreamWriter(stream, Encoding.UTF8, 1024, true))

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\StringExtensions.cs (1)

15return Encoding.UTF8.GetByteCount(value) == value.Length;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectReader.cs (1)

47_reader = new BinaryReader(stream, Encoding.UTF8, leaveOpen);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectWriter.cs (1)

94_writer = new BinaryWriter(stream, Encoding.UTF8, leaveOpen);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\TextEncodingKind.cs (3)

45TextEncodingKind.EncodingUtf8_BOM => Encoding.UTF8, 82Debug.Assert(HasPreamble(Encoding.UTF8)); 83kind = (encoding.Equals(Encoding.UTF8) || HasPreamble(encoding)) ? TextEncodingKind.EncodingUtf8_BOM : TextEncodingKind.EncodingUtf8;

DiscoverCommand.cs (1)

215new RazorInputFile(syntheticPath, "__rzc_discover__.cshtml", text: SourceText.From(string.Empty, Encoding.UTF8)),

PipeName.cs (1)

51var bytes = sha.ComputeHash(Encoding.UTF8.GetBytes(baseDirectory));

RazorSourceGeneratorHost.cs (2)

61["build_metadata.AdditionalFiles.TargetPath"] = Convert.ToBase64String(Encoding.UTF8.GetBytes(file.TargetPath)), 175return SourceText.From(stream, Encoding.UTF8);

ServerCommand.cs (1)

156using (var writer = new StreamWriter(fileStream, Encoding.UTF8, DefaultBufferSize, leaveOpen: true))

ServerProtocol\ServerLogger.cs (1)

116var bytes = Encoding.UTF8.GetBytes(output);

GenerateGuidFromName.cs (1)

20var nameBytes = System.Text.Encoding.UTF8.GetBytes(name ?? string.Empty);

Https\HttpsTests.4.1.0.cs (6)

82CustomBinding binding = new CustomBinding(new TextMessageEncodingBindingElement(MessageVersion.Soap11, Encoding.UTF8), new HttpsTransportBindingElement()); 160CustomBinding binding = new CustomBinding(new TextMessageEncodingBindingElement(MessageVersion.Soap11, Encoding.UTF8), new HttpsTransportBindingElement()); 199CustomBinding binding = new CustomBinding(new TextMessageEncodingBindingElement(MessageVersion.Soap12WSAddressing10, Encoding.UTF8), new HttpsTransportBindingElement()); 240CustomBinding binding = new CustomBinding(new TextMessageEncodingBindingElement(MessageVersion.Soap11, Encoding.UTF8), new HttpsTransportBindingElement()); 286CustomBinding binding = new CustomBinding(new TextMessageEncodingBindingElement(MessageVersion.Soap11, Encoding.UTF8), new HttpsTransportBindingElement()); 327CustomBinding binding = new CustomBinding(new TextMessageEncodingBindingElement(MessageVersion.Soap11, Encoding.UTF8), new HttpsTransportBindingElement());

Tcp\StreamingTests.4.1.0.cs (2)

411var reader = new StreamReader(stream, Encoding.UTF8); 418var sw = new StreamWriter(ms, Encoding.UTF8);

Consumer.cs (1)

20logger.LogInformation("Received message: {Message}", Encoding.UTF8.GetString(args.Message.Body));

ServerSentEvents\Helpers.cs (3)

65int maxByteCount = Encoding.UTF8.GetMaxByteCount(value.Length); 70bytesWritten = Encoding.UTF8.GetBytes(value, buffer); 116return Encoding.UTF8.GetString(bytes);

ServerSentEvents\SseParser.cs (1)

27/// that decodes the data of each event using <see cref="Encoding.UTF8"/>'s GetString method.

Microsoft\CSharp\CSharpCodeGenerator.cs (2)

3022using (StreamWriter sw = new StreamWriter(fs, Encoding.UTF8)) 3057using (var sw = new StreamWriter(fs, Encoding.UTF8))

System\CodeDom\Compiler\CodeCompiler.cs (3)

148using (var sw = new StreamWriter(fs, Encoding.UTF8)) 189using (var sw = new StreamWriter(fs, Encoding.UTF8)) 209using (var sw = new StreamWriter(fs, Encoding.UTF8))

System\CodeDom\Compiler\Executor.cs (2)

50using (var outputWriter = new StreamWriter(CreateInheritedFile(outputName), Encoding.UTF8)) 51using (var errorWriter = new StreamWriter(CreateInheritedFile(errorName), Encoding.UTF8))

System\ComponentModel\Design\DesigntimeLicenseContextSerializer.cs (2)

40using (BinaryWriter writer = new BinaryWriter(o, encoding: Text.Encoding.UTF8, leaveOpen: true)) 172using (BinaryReader reader = new BinaryReader(wrappedStream, encoding: Text.Encoding.UTF8, leaveOpen: true))

System\Configuration\BaseConfigurationRecord.cs (1)

3701StreamEncoding = Encoding.UTF8;

System\Configuration\ImplicitMachineConfigHost.cs (1)

68stream = new MemoryStream(Encoding.UTF8.GetBytes(ImplicitMachineConfig));

System\ConsolePal.Unix.cs (3)

1133data = stackalloc byte[Encoding.UTF8.GetMaxByteCount(value.Length)]; 1134int bytesToWrite = Encoding.UTF8.GetBytes(value, data); 1139data = Encoding.UTF8.GetBytes(value);

src\runtime\src\libraries\Common\src\Interop\Linux\procfs\Interop.ProcFsStat.TryReadStatusFile.cs (1)

155contents = Encoding.UTF8.GetString(bytes, 0, count);

src\runtime\src\libraries\Common\src\Interop\Unix\System.Native\Interop.ForkAndExecProcess.cs (6)

124dataByteLength = checked(dataByteLength + Encoding.UTF8.GetByteCount(str) + 1); // +1 for null terminator 142int bytesWritten = Encoding.UTF8.GetBytes(arr[i], data.Slice(dataOffset)); 165dataByteLength = checked(dataByteLength + Encoding.UTF8.GetByteCount(pair.Key) + 1 + Encoding.UTF8.GetByteCount(pair.Value) + 1); 189int keyBytes = Encoding.UTF8.GetBytes(pair.Key, data.Slice(dataOffset)); 191int valueBytes = Encoding.UTF8.GetBytes(pair.Value, data.Slice(dataOffset + keyBytes + 1));

src\runtime\src\libraries\Common\src\Interop\Unix\System.Native\Interop.ReadLink.cs (1)

54return Encoding.UTF8.GetString(spanBuffer.Slice(0, resultLength));

src\runtime\src\libraries\Common\src\System\Runtime\InteropServices\SpanOfCharAsUtf8StringMarshaller.cs (2)

44int exactByteCount = checked(Encoding.UTF8.GetByteCount(managed) + 1); // + 1 for null terminator 55int byteCount = Encoding.UTF8.GetBytes(managed, buffer);

System\Diagnostics\Process.Linux.cs (1)

296string argString = Encoding.UTF8.GetString(arg.Slice(nameStart));

System\Diagnostics\Process.Multiplexing.cs (1)

241encoding = Encoding.UTF8;

System\Formats\Tar\TarHeader.Read.cs (2)

794key = Encoding.UTF8.GetString(keySlice); 795value = Encoding.UTF8.GetString(valueSlice);

System\Formats\Tar\TarHeader.Write.cs (13)

System\Formats\Tar\TarHelpers.cs (1)

280return Encoding.UTF8.GetString(buffer);

System\IO\Compression\WinZipAesKeyMaterial.cs (2)

64int maxPasswordByteCount = Encoding.UTF8.GetMaxByteCount(password.Length); 71int actualByteCount = Encoding.UTF8.GetBytes(password, rentedPasswordBytes);

System\IO\Compression\ZipArchive.cs (1)

214get => (EntryNameAndCommentEncoding ?? Encoding.UTF8).GetString(_archiveComment);

System\IO\Compression\ZipArchiveEntry.cs (2)

588? Encoding.UTF8 589: _archive?.EntryNameAndCommentEncoding ?? Encoding.UTF8;

System\IO\Compression\ZipCryptoStream.cs (2)

129byte[] passwordBytes = ArrayPool<byte>.Shared.Rent(Encoding.UTF8.GetMaxByteCount(password.Length)); 132int byteCount = Encoding.UTF8.GetBytes(password, passwordBytes);

System\IO\Compression\ZipHelper.cs (1)

29return Encoding.UTF8;

System\IO\FileSystemWatcher.Linux.cs (1)

925Encoding.UTF8.GetString(_buffer, position, lengthWithoutNullTerm) :

System\IO\MemoryMappedFiles\MemoryMappedFile.Unix.cs (2)

205Debug.Fail($"shm_open failed with ENAMETOOLONG for {Encoding.UTF8.GetByteCount(mapName)} byte long name."); 263Debug.Assert(Encoding.UTF8.GetByteCount(span) <= MaxNameLength); // the standard uses Utf8

System\IO\Packaging\InternalRelationshipCollection.cs (1)

457using (XmlWriter writer = XmlWriter.Create(s, new XmlWriterSettings { Encoding = System.Text.Encoding.UTF8 }))

System\IO\Packaging\PartBasedPackageProperties.cs (1)

687_xmlWriter = XmlWriter.Create(writerStream, new XmlWriterSettings { Encoding = System.Text.Encoding.UTF8 });

System\IO\Packaging\ZipPackage.cs (1)

911using (XmlWriter writer = XmlWriter.Create(s, new XmlWriterSettings { Encoding = System.Text.Encoding.UTF8 }))

System\Management\WMIGenerator.cs (1)

185tw = new StreamWriter(new FileStream(filePath, FileMode.Create), System.Text.Encoding.UTF8);

System\BinaryData.cs (2)

144_bytes = Encoding.UTF8.GetBytes(data); 419public override string ToString() => Encoding.UTF8.GetString(_bytes.Span);

System\Net\Http\Headers\ContentDispositionHeaderValue.cs (1)

439byte[] buffer = Encoding.UTF8.GetBytes(input);

System\Net\Http\Headers\HeaderUtilities.cs (2)

71byte[] utf8bytes = ArrayPool<byte>.Shared.Rent(Encoding.UTF8.GetMaxByteCount(input.Length)); 72int utf8length = Encoding.UTF8.GetBytes(input, 0, input.Length, utf8bytes, 0);

System\Net\Http\HttpContent.cs (3)

26internal static readonly Encoding DefaultStringEncoding = Encoding.UTF8; 42AssertEncodingConstants(Encoding.UTF8, UTF8CodePage, UTF8Preamble); 739encoding = Encoding.UTF8;

System\Net\Http\SocketsHttpHandler\AuthenticationHelper.cs (1)

182string base64AuthString = Convert.ToBase64String(Encoding.UTF8.GetBytes(authString));

System\Net\Http\SocketsHttpHandler\AuthenticationHelper.Digest.cs (1)

216byte[] dataBytes = Encoding.UTF8.GetBytes(data);

System\Net\Http\SocketsHttpHandler\SocksHelper.cs (2)

325return checked((byte)Encoding.UTF8.GetBytes(chars, buffer)); 329Debug.Assert(Encoding.UTF8.GetByteCount(chars) > 255);

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

136return JsonHelpers.GetEncoding(content) is Encoding sourceEncoding && sourceEncoding != Encoding.UTF8

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

20return Encoding.CreateTranscodingStream(contentStream, innerStreamEncoding: sourceEncoding, outerStreamEncoding: Encoding.UTF8);

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

117return targetEncoding != null && targetEncoding != Encoding.UTF8 126Stream transcodingStream = Encoding.CreateTranscodingStream(targetStream, targetEncoding, Encoding.UTF8, leaveOpen: true);

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

16if (JsonHelpers.GetEncoding(this) is Encoding targetEncoding && targetEncoding != Encoding.UTF8)

System\Net\Http\WinHttpRequestStream.cs (1)

212byte[] chunkSize = Encoding.UTF8.GetBytes($"{count:x}\r\n");

src\runtime\src\libraries\Common\src\System\Net\WebSockets\WebSocketValidate.cs (2)

85Encoding.UTF8.GetMaxByteCount(statusDescription.Length) > MaxControlFramePayloadLength && 86Encoding.UTF8.GetByteCount(statusDescription) > MaxControlFramePayloadLength)

System\Net\Managed\HttpListenerContext.Managed.cs (1)

67string authString = Encoding.UTF8.GetString(Convert.FromBase64String(headerValue));

System\Net\WebSockets\HttpWebSocket.cs (1)

22byte[] toHash = Encoding.UTF8.GetBytes(acceptString);

System\Net\BufferBuilder.cs (2)

78int byteCount = Encoding.UTF8.GetByteCount(value, offset, count); 80Encoding.UTF8.GetBytes(value, offset, count, _buffer, _offset);

System\Net\Mail\SmtpLoginAuthenticationModule.cs (2)

39return new Authorization(Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(userName)), false); 45return new Authorization(Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(cachedCredential.Password)), true);

System\Net\Mail\SmtpReplyReaderFactory.cs (1)

308builder.Append(Encoding.UTF8.GetString(_byteBuffer, start, actual));

System\Net\Mime\MimeBasePart.cs (1)

23encoding == Encoding.Unicode || encoding == Encoding.UTF8 || encoding == Encoding.UTF32 || encoding == Encoding.BigEndianUnicode;

System\Net\DnsResolverPal.Managed.cs (1)

257values.Add(Encoding.UTF8.GetString(str));

src\runtime\src\libraries\Common\src\System\Runtime\InteropServices\SpanOfCharAsUtf8StringMarshaller.cs (2)

44int exactByteCount = checked(Encoding.UTF8.GetByteCount(managed) + 1); // + 1 for null terminator 55int byteCount = Encoding.UTF8.GetBytes(managed, buffer);

src\runtime\src\libraries\Common\src\System\Net\NetworkInformation\InterfaceInfoPal.Unix.cs (2)

39bufferSize = Encoding.UTF8.GetByteCount(castInterfaceName) + 1; 60Encoding.UTF8.GetBytes(castInterfaceName, buffer);

src\runtime\src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.ASN1.cs (2)

72return Encoding.UTF8.GetString(bufStack, bytesNeeded); 98return Encoding.UTF8.GetString(buf, bytesNeeded);

System\Net\Quic\QuicListener.cs (1)

346SslClientHelloInfo clientHello = new SslClientHelloInfo(data.Info->ServerNameLength > 0 ? Encoding.UTF8.GetString((byte*)data.Info->ServerName, data.Info->ServerNameLength) : "", SslProtocols.Tls13);

System\Net\CommandStream.cs (1)

471private Encoding _encoding = Encoding.UTF8;

System\Net\FtpControlStream.cs (1)

289Encoding = Encoding.UTF8;

src\runtime\src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.ASN1.cs (2)

72return Encoding.UTF8.GetString(bufStack, bytesNeeded); 98return Encoding.UTF8.GetString(buf, bytesNeeded);

src\runtime\src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.OpenSsl.cs (1)

647index += Encoding.UTF8.GetBytes(alg, buffer.AsSpan(index));

src\runtime\src\libraries\Common\src\Microsoft\Win32\SafeHandles\GssSafeHandles.cs (3)

22out minorStatus, name, Encoding.UTF8.GetByteCount(name), out retHandle); 39out minorStatus, name, Encoding.UTF8.GetByteCount(name), out retHandle); 120status = Interop.NetSecurityNative.InitiateCredWithPassword(out minorStatus, packageType, userHandle, password, Encoding.UTF8.GetByteCount(password), out retHandle);

System\Net\NegotiateAuthenticationPal.Unix.cs (1)

534return Encoding.UTF8.GetString(tokenBytes);

System\Net\Security\SslApplicationProtocol.cs (1)

12private static readonly Encoding s_utf8 = Encoding.GetEncoding(Encoding.UTF8.CodePage, EncoderFallback.ExceptionFallback, DecoderFallback.ExceptionFallback);

System\Net\ServerSentEvents\Helpers.cs (2)

48int maxByteCount = Encoding.UTF8.GetMaxByteCount(value.Length); 52int bytesWritten = Encoding.UTF8.GetBytes(value, buffer);

System\Net\ServerSentEvents\SseParser_1.cs (2)

431_eventType = Encoding.UTF8.GetString(fieldValue); 439LastEventId = _eventId = Encoding.UTF8.GetString(fieldValue);

System\Net\ServerSentEvents\SseParser.cs (2)

24/// that decodes the data of each event using <see cref="Encoding.UTF8"/>'s GetString method. 27Create(sseStream, static (_, bytes) => Encoding.UTF8.GetString(bytes));

System\Net\Sockets\UnixDomainSocketEndPoint.cs (3)

40int bufferLength = Encoding.UTF8.GetByteCount(path); 56int bytesEncoded = Encoding.UTF8.GetBytes(path, 0, path.Length, _encodedPath, 0); 89_path = Encoding.UTF8.GetString(_encodedPath, 0, length);

System\Net\WebClient.cs (2)

510formHeaderBytes = Encoding.UTF8.GetBytes(formHeader); 1086private static readonly Encoding[] s_knownEncodings = { Encoding.UTF8, Encoding.UTF32, Encoding.Unicode, Encoding.BigEndianUnicode };

src\runtime\src\libraries\Common\src\System\Net\WebSockets\WebSocketValidate.cs (2)

85Encoding.UTF8.GetMaxByteCount(statusDescription.Length) > MaxControlFramePayloadLength && 86Encoding.UTF8.GetByteCount(statusDescription) > MaxControlFramePayloadLength)

src\runtime\src\libraries\Common\src\System\Net\WebSockets\WebSocketValidate.cs (2)

85Encoding.UTF8.GetMaxByteCount(statusDescription.Length) > MaxControlFramePayloadLength && 86Encoding.UTF8.GetByteCount(statusDescription) > MaxControlFramePayloadLength)

Internal\Runtime\Augments\RuntimeAugments.cs (1)

625string modulePath = System.Text.Encoding.UTF8.GetString(pModuleNameUtf8, numUtf8Chars);

Internal\Runtime\CompilerHelpers\InteropHelpers.cs (2)

288return Encoding.UTF8.GetString(pModuleName, string.strlen(pModuleName)); 386string entryPointName = Encoding.UTF8.GetString(methodName, string.strlen(methodName));

src\runtime\src\coreclr\tools\Common\Internal\NativeFormat\NativeFormatReader.String.cs (1)

76value = Encoding.UTF8.GetString(_base + offset, (int)numBytes);

src\runtime\src\libraries\Common\src\Interop\Linux\procfs\Interop.ProcFsStat.TryReadStatusFile.cs (1)

155contents = Encoding.UTF8.GetString(bytes, 0, count);

src\runtime\src\libraries\Common\src\Interop\Unix\System.Native\Interop.ReadDir.cs (2)

43ReadOnlySpan<char> result = !Encoding.UTF8.TryGetChars(nameBytes, buffer, out int charsWritten) 44? Encoding.UTF8.GetString(nameBytes) // Fallback to allocation since this is a rare case

src\runtime\src\libraries\Common\src\Interop\Unix\System.Native\Interop.ReadLink.cs (1)

54return Encoding.UTF8.GetString(spanBuffer.Slice(0, resultLength));

src\runtime\src\libraries\Common\src\System\Runtime\InteropServices\SpanOfCharAsUtf8StringMarshaller.cs (2)

44int exactByteCount = checked(Encoding.UTF8.GetByteCount(managed) + 1); // + 1 for null terminator 55int byteCount = Encoding.UTF8.GetBytes(managed, buffer);

src\runtime\src\libraries\System.Private.CoreLib\src\Internal\Console.Unix.cs (2)

29int byteCount = Encoding.UTF8.GetByteCount(s); 31int cbytes = Encoding.UTF8.GetBytes(s, bytes);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventProvider.cs (2)

1266string key = Text.Encoding.UTF8.GetString(data, dataStart, keyEnd - dataStart); 1267string value = Text.Encoding.UTF8.GetString(data, valueIdx, valueEnd - valueIdx);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventSource.cs (1)

446return (manifestBytes == null) ? null : Encoding.UTF8.GetString(manifestBytes, 0, manifestBytes.Length);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\ManifestBuilder.cs (1)

339return (str != "") ? Encoding.UTF8.GetBytes(str) : [];

src\runtime\src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\TraceLogging\FieldMetadata.cs (2)

112this.nameSize = Encoding.UTF8.GetByteCount(this.name) + 1; 171Encoding.UTF8.GetBytes(this.name, 0, this.name.Length, metadata, pos);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\TraceLogging\Statics.cs (2)

88int metadataSize = Encoding.UTF8.GetByteCount(name) + 3 + prefixSize + suffixSize; 93Encoding.UTF8.GetBytes(name, 0, name.Length, metadata, 2 + prefixSize);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\TraceLogging\TraceLoggingEventSource.cs (2)

804metaData.AddRange(Encoding.UTF8.GetBytes(value.Substring(1))); 824metaData.AddRange(Encoding.UTF8.GetBytes(value));

src\runtime\src\libraries\System.Private.CoreLib\src\System\Environment.Variables.Unix.cs (1)

162key = Encoding.UTF8.GetString(entry, checked((int)(splitpoint - entry)));

src\runtime\src\libraries\System.Private.CoreLib\src\System\Globalization\CompareInfo.Utf8.cs (2)

83int sourceMaxCharCount = Encoding.UTF8.GetMaxCharCount(source.Length); 114int prefixMaxCharCount = Encoding.UTF8.GetMaxCharCount(prefix.Length);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Globalization\DateTimeFormat.cs (2)

771Encoding.UTF8.GetBytes(s, Unsafe.BitCast<Span<TChar>, Span<byte>>(result.AppendSpan(Encoding.UTF8.GetByteCount(s))));

src\runtime\src\libraries\System.Private.CoreLib\src\System\Globalization\DateTimeFormatInfo.cs (5)

367Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(amDesignatorUtf8 ??= Encoding.UTF8.GetBytes(AMDesignator)); 616Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(dateSeparatorUtf8 ??= Encoding.UTF8.GetBytes(DateSeparator)); 819Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(pmDesignatorUtf8 ??= Encoding.UTF8.GetBytes(PMDesignator)); 1001Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(timeSeparatorUtf8 ??= Encoding.UTF8.GetBytes(TimeSeparator)); 1701Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_decimalSeparatorUtf8 ??= Encoding.UTF8.GetBytes(DecimalSeparator));

src\runtime\src\libraries\System.Private.CoreLib\src\System\Globalization\NumberFormatInfo.cs (2)

112byte[] utf8 = new byte[Encoding.UTF8.GetByteCount(value) + 1]; 113Encoding.UTF8.GetBytes(value, utf8);

src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\BinaryReader.cs (1)

31public BinaryReader(Stream input) : this(input, Encoding.UTF8, false)

src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\BinaryWriter.cs (2)

32_encoding = Encoding.UTF8; 37public BinaryWriter(Stream output) : this(output, Encoding.UTF8, false)

src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\Directory.Unix.cs (5)

32int tempPathByteCount = Encoding.UTF8.GetByteCount(tempPath); 33int prefixByteCount = prefix is not null ? Encoding.UTF8.GetByteCount(prefix) : 0; 37int pos = Encoding.UTF8.GetBytes(tempPath, path); 40pos += Encoding.UTF8.GetBytes(prefix, path.Slice(pos)); 56return Encoding.UTF8.GetString(path.Slice(0, path.Length - 1)); // trim off the trailing '\0'

src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\File.cs (6)

650=> ReadAllText(path, Encoding.UTF8); 892=> ReadAllLines(path, Encoding.UTF8); 911=> ReadLines(path, Encoding.UTF8); 927=> ReadLinesAsync(path, Encoding.UTF8, cancellationToken); 1112=> ReadAllTextAsync(path, Encoding.UTF8, cancellationToken); 1322=> ReadAllLinesAsync(path, Encoding.UTF8, cancellationToken);

src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\FileInfo.cs (1)

87StreamReader reader = new StreamReader(NormalizedPath, Encoding.UTF8, detectEncodingFromByteOrderMarks: true);

src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\Path.Unix.cs (3)

103int tempPathByteCount = Encoding.UTF8.GetByteCount(tempPath); 107int pos = Encoding.UTF8.GetBytes(tempPath, path); 121return Encoding.UTF8.GetString(path.Slice(0, path.Length - 1)); // trim off the trailing '\0'

src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\StreamReader.cs (5)

136: this(stream, Encoding.UTF8, detectEncodingFromByteOrderMarks, DefaultBufferSize, leaveOpen: false) 184_encoding = encoding ??= Encoding.UTF8; 212: this(path, Encoding.UTF8, detectEncodingFromByteOrderMarks, DefaultBufferSize) 232: this(path, Encoding.UTF8, detectEncodingFromByteOrderMarks: true, options) 533_encoding = Encoding.UTF8;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Net\WebUtility.cs (3)

345int byteCount = Encoding.UTF8.GetByteCount(value); 351Encoding.UTF8.GetBytes(state.value, utf8Bytes); 560return UrlDecodeInternal(encodedValue, Encoding.UTF8);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Number.Formatting.cs (1)

1114return Encoding.UTF8.TryGetBytes(source, Unsafe.BitCast<Span<TChar>, Span<byte>>(destination), out charsWritten);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Number.Parsing.cs (1)

1722SR.Format(SR.Format_InvalidStringWithValue, Encoding.UTF8.GetString(bytes)) :

src\runtime\src\libraries\System.Private.CoreLib\src\System\Numerics\INumberBase.cs (5)

310int textMaxCharCount = Encoding.UTF8.GetMaxCharCount(utf8Text.Length); 492int textMaxCharCount = Encoding.UTF8.GetMaxCharCount(utf8Text.Length); 562int destinationMaxCharCount = Encoding.UTF8.GetMaxCharCount(utf8Destination.Length); 618int textMaxCharCount = Encoding.UTF8.GetMaxCharCount(utf8Text.Length); 665int textMaxCharCount = Encoding.UTF8.GetMaxCharCount(utf8Text.Length);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Resources\ResourceReader.Core.cs (1)

34_store = new BinaryReader(stream, Encoding.UTF8);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Resources\ResourceReader.cs (2)

101_store = new BinaryReader(new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read, DefaultFileStreamBufferSize, FileOptions.RandomAccess), Encoding.UTF8); 129_store = new BinaryReader(stream, Encoding.UTF8);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshal.cs (6)

77return string.CreateStringFromEncoding((byte*)ptr, nbBytes, Encoding.UTF8); 85return string.CreateStringFromEncoding((byte*)ptr, byteLen, Encoding.UTF8); 1072int nb = Encoding.UTF8.GetMaxByteCount(s.Length); 1077int nbWritten = Encoding.UTF8.GetBytes(s, new Span<byte>(pbMem, nb)); 1113int nb = Encoding.UTF8.GetMaxByteCount(s.Length); 1118int nbWritten = Encoding.UTF8.GetBytes(s, new Span<byte>(pbMem, nb));

src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshal.Unix.cs (3)

40int convertedBytes = Encoding.UTF8.GetBytes(s, new Span<byte>(buffer, bufferLength)); 49int byteLength = Encoding.UTF8.GetByteCount(chars); 56int actualByteLength = Encoding.UTF8.GetBytes(chars, bytes);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshalling\Utf8StringMarshaller.cs (4)

28int exactByteCount = checked(Encoding.UTF8.GetByteCount(managed) + 1); // + 1 for null terminator 32int byteCount = Encoding.UTF8.GetBytes(managed, buffer); 87int exactByteCount = checked(Encoding.UTF8.GetByteCount(managed) + 1); // + 1 for null terminator 98int byteCount = Encoding.UTF8.GetBytes(managed, buffer);

src\runtime\src\libraries\System.Private.CoreLib\src\System\String.cs (1)

249return CreateStringFromEncoding(pb, numBytes, Encoding.UTF8);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\Encoding.cs (1)

213case CodePageUTF8: return UTF8; // 65001

src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\Unicode\Utf8.cs (1)

574if (Encoding.UTF8.TryGetBytes(value, _destination.Slice(_pos), out int bytesWritten))

src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\UTF8Encoding.Sealed.cs (1)

15/// of calls made directly off of <see cref="Encoding.UTF8"/>. See https://github.com/dotnet/coreclr/pull/9230.

src\runtime\src\libraries\System.Private.CoreLib\src\System\TimeZoneInfo.Unix.cs (1)

1210Encoding enc = Encoding.UTF8;

src\runtime\src\libraries\System.Private.CoreLib\src\System\TimeZoneInfo.Unix.NonAndroid.cs (1)

174using var reader = new StreamReader(fileName, Encoding.UTF8);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Version.cs (1)

459Encoding.UTF8.GetString(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(originalInput));

System\AppContext.NativeAot.cs (2)

20Encoding.UTF8.GetString(keys[i], string.strlen(keys[i])), 21Encoding.UTF8.GetString(values[i], string.strlen(values[i])));

System\CrashInfo.cs (2)

378int size = Encoding.UTF8.GetByteCount(chars); 384Encoding.UTF8.GetBytes(chars, destination);

System\Runtime\InteropServices\PInvokeMarshal.Unix.cs (5)

32return System.Text.Encoding.UTF8.GetChars(multiByteStr, multiByteLen, wideCharStr, wideCharLen); 43return System.Text.Encoding.UTF8.GetBytes(wideCharStr, wideCharLen, multiByteStr, multiByteLen); 52return System.Text.Encoding.UTF8.GetBytes(wideCharStr, wideCharLen, multiByteStr, multiByteLen); 57return System.Text.Encoding.UTF8.GetByteCount(wideCharStr, wideCharLen); 62return System.Text.Encoding.UTF8.GetCharCount(multiByteStr, multiByteLen);

NativeRuntimeEventSourceGenerator.cs (1)

56spc.AddSource($"{className}.g.cs", SourceText.From(source, System.Text.Encoding.UTF8));

System\Runtime\Serialization\DataContract.cs (1)

1747byte[] namespaceBytes = Encoding.UTF8.GetBytes(namespaces);

System\Runtime\Serialization\Json\DataContractJsonSerializer.cs (1)

303XmlDictionaryWriter jsonWriter = JsonReaderWriterFactory.CreateJsonWriter(stream, Encoding.UTF8, false); // ownsStream

System\Runtime\Serialization\Json\JsonEncodingStreamWrapper.cs (1)

195_byteCount = Encoding.UTF8.GetBytes(_chars, 0, charCount, _bytes, 0);

System\Runtime\Serialization\Json\JsonReaderWriterFactory.cs (1)

50return CreateJsonWriter(stream, Encoding.UTF8, true);

System\Runtime\Serialization\Json\JsonXmlDataContract.cs (1)

33StringStream stream = new(xmlContent, Encoding.UTF8);

System\Runtime\Serialization\Json\XmlJsonReader.cs (8)

603XmlExceptionHelper.ThrowTokenExpected(this, "false", Encoding.UTF8.GetString(buffer, offset, 5)); 611XmlExceptionHelper.ThrowTokenExpected(this, "false", Encoding.UTF8.GetString(buffer, offset, 4) + (char)ch); 624XmlExceptionHelper.ThrowTokenExpected(this, "true", Encoding.UTF8.GetString(buffer, offset, 4)); 632XmlExceptionHelper.ThrowTokenExpected(this, "true", Encoding.UTF8.GetString(buffer, offset, 4) + (char)ch); 645XmlExceptionHelper.ThrowTokenExpected(this, "null", Encoding.UTF8.GetString(buffer, offset, 4)); 658XmlExceptionHelper.ThrowTokenExpected(this, "null", Encoding.UTF8.GetString(buffer, offset, 4) + (char)ch); 1196string bufferAsString = Encoding.UTF8.GetString(buffer, offset, 4); 1207bufferAsString = Encoding.UTF8.GetString(buffer, offset, 4);

System\Runtime\Serialization\Json\XmlJsonWriter.cs (1)

241if (encoding.WebName != Encoding.UTF8.WebName)

System\Runtime\Serialization\XmlObjectSerializer.cs (1)

37XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(stream, Encoding.UTF8, false /*ownsStream*/);

System\Xml\EncodingStreamWrapper.cs (1)

612_byteCount = Encoding.UTF8.GetBytes(_chars, 0, charCount, _bytes, 0);

System\Xml\XmlBaseWriter.cs (1)

1644_textFragmentWriter.SetOutput(stream, false, Encoding.UTF8);

System\Xml\XmlCanonicalWriter.cs (7)

184_element.prefixLength = Encoding.UTF8.GetByteCount(prefix); 186_element.localNameLength = Encoding.UTF8.GetByteCount(localName); 254if (string.Equals(Encoding.UTF8.GetString(_xmlnsBuffer!, xmlnsAttribute.prefixOffset, xmlnsAttribute.prefixLength), _inclusivePrefixes[i], StringComparison.Ordinal)) 371xmlnsAttribute.prefixLength = Encoding.UTF8.GetBytes(prefix, 0, prefix.Length, _xmlnsBuffer, _xmlnsOffset); 374xmlnsAttribute.nsLength = Encoding.UTF8.GetBytes(ns, 0, ns.Length, _xmlnsBuffer, _xmlnsOffset); 424_attribute.prefixLength = Encoding.UTF8.GetByteCount(prefix); 426_attribute.localNameLength = Encoding.UTF8.GetByteCount(localName);

System\Xml\XmlDictionaryString.cs (1)

78return _buffer ??= System.Text.Encoding.UTF8.GetBytes(_value);

System\Xml\XmlNodeWriter.cs (8)

System\Xml\XmlUTF8TextReader.cs (2)

646XmlExceptionHelper.ThrowTokenExpected(this, "?>", Encoding.UTF8.GetString(buffer, offset, 2)); 1061XmlExceptionHelper.ThrowTokenExpected(this, "[CDATA[", Encoding.UTF8.GetString(buffer, offset, 7));

System\Xml\XmlUTF8TextWriter.cs (2)

25if (encoding.WebName != Encoding.UTF8.WebName) 93if (encoding != null && encoding.CodePage == Encoding.UTF8.CodePage)

src\runtime\src\coreclr\tools\Common\Internal\NativeFormat\NativeFormatReader.String.cs (1)

76value = Encoding.UTF8.GetString(_base + offset, (int)numBytes);

Internal\StackTraceMetadata\StackTraceMetadata.cs (1)

178string documentName = System.Text.Encoding.UTF8.GetString(MemoryMarshal.CreateReadOnlySpanFromNullTerminated(documentAddress));

src\runtime\src\coreclr\tools\Common\Internal\NativeFormat\NativeFormatReader.String.cs (1)

76value = Encoding.UTF8.GetString(_base + offset, (int)numBytes);

src\runtime\src\coreclr\tools\Common\Internal\Text\Utf8Span.cs (2)

40return Encoding.UTF8.GetString(_value) == value; 59public override string ToString() => Encoding.UTF8.GetString(_value);

src\runtime\src\coreclr\tools\Common\TypeSystem\Common\DefType.cs (2)

23public string GetNamespace() => System.Text.Encoding.UTF8.GetString(Namespace 36public string GetName() => System.Text.Encoding.UTF8.GetString(Name

src\runtime\src\coreclr\tools\Common\TypeSystem\Common\FieldDesc.cs (1)

44return System.Text.Encoding.UTF8.GetString(

src\runtime\src\coreclr\tools\Common\TypeSystem\Common\MethodDesc.cs (1)

601return System.Text.Encoding.UTF8.GetString(Name

System\Private\Windows\BinaryFormat\Support\BinaryFormatWriterScope.cs (1)

15Writer = new BinaryWriter(stream, Encoding.UTF8, leaveOpen: true);

System\Private\Windows\Ole\Composition.ManagedToNativeAdapter.cs (2)

415int byteCount = Encoding.UTF8.GetByteCount(value); 425byteCount = Encoding.UTF8.GetBytes(value, span);

System\Private\Windows\Ole\Composition.NativeToManagedAdapter.cs (1)

301return Encoding.UTF8.GetString(bytes);

System\Xml\Core\XmlTextReaderImpl.cs (1)

3177_ps.encoding = Encoding.UTF8;

System\Xml\Core\XmlWriterSettings.cs (2)

367Debug.Assert(Encoding.UTF8.WebName == "utf-8"); 503_encoding = Encoding.UTF8;

System\Xml\Serialization\Compiler.cs (1)

94byte[] valueBytes = Encoding.UTF8.GetBytes(value);

System\Xml\Xsl\XsltOld\SequentialOutput.cs (1)

609_utf8Encoding = Encoding.UTF8;

System\Xml\Xsl\XsltOld\XsltOutput.cs (1)

26private Encoding _encoding = System.Text.Encoding.UTF8;

System\Reflection\Emit\CustomAttributeWrapper.cs (1)

97return Text.Encoding.UTF8.GetString(data.Slice(pos, len));

System\Reflection\Internal\Utilities\MemoryBlock.cs (1)

282return Encoding.UTF8.GetString(Pointer + offset, byteCount);

System\Reflection\Metadata\BlobWriter.cs (1)

473int byteCount = Encoding.UTF8.GetByteCount(charPtr, length);

System\Reflection\Metadata\Ecma335\MetadataBuilder.Heaps.cs (1)

560stringVirtualIndexToHeapOffsetMap[entry.Value.GetWriterVirtualIndex()] = position - (Encoding.UTF8.GetByteCount(entry.Key) + 1);

System\Reflection\Metadata\Ecma335\MetadataRootBuilder.cs (2)

62Debug.Assert(Encoding.UTF8.GetByteCount(DefaultMetadataVersionString) == DefaultMetadataVersionString.Length); 63int metadataVersionByteCount = metadataVersion != null ? Encoding.UTF8.GetByteCount(metadataVersion) : DefaultMetadataVersionString.Length;

System\Reflection\Metadata\Ecma335\PortablePdbBuilder.cs (1)

64Debug.Assert(Encoding.UTF8.GetByteCount(MetadataVersion) == MetadataVersion.Length);

System\Reflection\Metadata\Internal\StringHeap.cs (1)

215StringKind.Virtual => Encoding.UTF8.GetBytes(GetVirtualString(handle.GetVirtualIndex())),

System\Reflection\Metadata\MetadataStringDecoder.cs (1)

35public static MetadataStringDecoder DefaultUTF8 { get; } = new MetadataStringDecoder(Encoding.UTF8);

System\Reflection\PortableExecutable\PEBinaryReader.cs (2)

32_reader = new BinaryReader(stream, Encoding.UTF8, leaveOpen: true); 107return Encoding.UTF8.GetString(bytes, 0, nonPaddedLength);

System\Reflection\TypeLoading\General\Helpers.cs (2)

355public static byte[] ToUtf8(this string s) => Encoding.UTF8.GetBytes(s); 357public static string ToUtf16(this ReadOnlySpan<byte> utf8) => Encoding.UTF8.GetString(utf8);

src\runtime\src\libraries\Common\src\System\Resources\ResourceWriter.cs (2)

248BinaryWriter bw = new BinaryWriter(_output, Encoding.UTF8); 303BinaryWriter data = new BinaryWriter(dataSection, Encoding.UTF8);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Resources\ResourceReader.cs (2)

101_store = new BinaryReader(new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read, DefaultFileStreamBufferSize, FileOptions.RandomAccess), Encoding.UTF8); 129_store = new BinaryReader(stream, Encoding.UTF8);

src\runtime\src\libraries\Common\src\System\Resources\ResourceWriter.cs (2)

248BinaryWriter bw = new BinaryWriter(_output, Encoding.UTF8); 303BinaryWriter data = new BinaryWriter(dataSection, Encoding.UTF8);

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

106return Encoding.UTF8.GetString(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(slice));

System\Number.BigInteger.cs (1)

987strResult = Encoding.UTF8.GetString(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(vlb.AsSpan()));

System\Number.Polyfill.cs (1)

125return Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(Encoding.UTF8.GetBytes(value));

src\runtime\src\libraries\Common\src\System\Security\Cryptography\PasswordBasedEncryption.cs (3)

210encoding = System.Text.Encoding.UTF8; 357System.Text.Encoding encoding = System.Text.Encoding.UTF8; 495encoding = System.Text.Encoding.UTF8;

System\Security\Cryptography\Rfc2898DeriveBytes.cs (2)

59Encoding.UTF8.GetBytes(password ?? throw new ArgumentNullException(nameof(password))), 89byte[] passwordBytes = Encoding.UTF8.GetBytes(password);

src\runtime\src\libraries\Common\src\System\Security\Cryptography\PasswordBasedEncryption.cs (3)

210encoding = System.Text.Encoding.UTF8; 357System.Text.Encoding encoding = System.Text.Encoding.UTF8; 495encoding = System.Text.Encoding.UTF8;

System\Security\Cryptography\Xml\CanonicalXml.cs (1)

102return Encoding.UTF8.GetBytes(sb.ToString());

System\Security\Cryptography\Xml\CanonicalXmlAttribute.cs (2)

35byte[] rgbData = Encoding.UTF8.GetBytes(" " + Name + "=\""); 37rgbData = Encoding.UTF8.GetBytes(Utils.EscapeAttributeValue(Value));

System\Security\Cryptography\Xml\CanonicalXmlCDataSection.cs (1)

34byte[] rgbData = Encoding.UTF8.GetBytes(Utils.EscapeCData(Data));

System\Security\Cryptography\Xml\CanonicalXmlComment.cs (1)

61rgbData = Encoding.UTF8.GetBytes(Value!);

System\Security\Cryptography\Xml\CanonicalXmlElement.cs (2)

139rgbData = Encoding.UTF8.GetBytes("<" + Name); 167rgbData = Encoding.UTF8.GetBytes("</" + Name + ">");

System\Security\Cryptography\Xml\CanonicalXmlProcessingInstruction.cs (2)

57rgbData = Encoding.UTF8.GetBytes(Name); 62rgbData = Encoding.UTF8.GetBytes(" " + Value);

System\Security\Cryptography\Xml\CanonicalXmlSignificantWhitespace.cs (1)

36byte[] rgbData = Encoding.UTF8.GetBytes(Utils.EscapeWhitespaceData(Value));

System\Security\Cryptography\Xml\CanonicalXmlText.cs (1)

36byte[] rgbData = Encoding.UTF8.GetBytes(Utils.EscapeTextData(Value));

System\Security\Cryptography\Xml\CanonicalXmlWhitespace.cs (1)

36byte[] rgbData = Encoding.UTF8.GetBytes(Utils.EscapeWhitespaceData(Value));

System\Security\Cryptography\Xml\EncryptedXml.cs (1)

114_encoding = Encoding.UTF8;

System\Security\Cryptography\Xml\ExcCanonicalXml.cs (1)

55return Encoding.UTF8.GetBytes(sb.ToString());

System\Security\Cryptography\Xml\SignedXmlDebugLog.cs (1)

605Encoding.UTF8.GetString(ms.ToArray()));

System\Security\Cryptography\Xml\XmlDsigBase64Transform.cs (1)

101byte[] buffer = Encoding.UTF8.GetBytes(sb.ToString());

System\ServiceModel\Federation\WSTrustChannelSecurityTokenProvider.cs (2)

237var writer = XmlDictionaryWriter.CreateTextWriter(memeoryStream, Encoding.UTF8); 276var writer = XmlDictionaryWriter.CreateTextWriter(memeoryStream, Encoding.UTF8);

System\ServiceModel\Channels\HttpChannelHelpers.cs (1)

189return Encoding.UTF8.GetString(responseBuffer, 0, bytesToRead);

System\ServiceModel\Channels\FramingDecoders.cs (1)

165_value = Encoding.UTF8.GetString(_encodedBytes, 0, _encodedSize);

System\ServiceModel\Channels\FramingEncoders.cs (2)

56int valueByteCount = Encoding.UTF8.GetByteCount(value); 62Encoding.UTF8.GetBytes(value, EncodedBytes.Slice(offset).Span);

System\ServiceModel\Channels\PipeConnectionInitiator.cs (1)

357byte[] canonicalBytes = Encoding.UTF8.GetBytes(canonicalName);

Internals\System\Runtime\UrlUtility.cs (4)

32return ParseQueryString(query, Encoding.UTF8); 61return UrlEncode(str, Encoding.UTF8); 80return UrlEncodeSpaces(UrlEncodeNonAscii(str, Encoding.UTF8)); 152e = Encoding.UTF8;

Internals\System\Xml\XmlMtomWriter.cs (1)

194if (string.Compare(name, Encoding.UTF8.WebName, StringComparison.OrdinalIgnoreCase) == 0)

System\IdentityModel\CanonicalFormWriter.cs (1)

14internal static readonly Encoding Utf8WithoutPreamble = Encoding.UTF8;

System\ServiceModel\Channels\BinaryMessageEncoder.cs (5)

381int utf8ValueSize = Encoding.UTF8.GetByteCount(newStrings[i].Value); 412int utf8ValueSize = Encoding.UTF8.GetByteCount(newString); 414offset += Encoding.UTF8.GetBytes(newString, 0, newString.Length, buffer, offset); 486string value = Encoding.UTF8.GetString(buffer, offset, utf8ValueSize); 903int bytesRequired = Encoding.UTF8.GetByteCount(s.Value);

System\ServiceModel\Channels\TransportDefaults.cs (2)

50public static readonly Encoding[] SupportedEncodings = new Encoding[] { Encoding.UTF8, Encoding.Unicode, Encoding.BigEndianUnicode }; 55new CharSetEncoding("utf-8", Encoding.UTF8),

System\ServiceModel\Security\Tokens\DerivedKeySecurityToken.cs (1)

201(_label != null ? Encoding.UTF8.GetBytes(_label) : s_DefaultLabel), _nonce, Length * 8,

System\ServiceModel\Security\WSSecurityOneDotZeroSendSecurityHeader.cs (2)

520using (var xmlWriter = XmlDictionaryWriter.CreateTextWriter(stream, Encoding.UTF8, false)) 626using (var xmlWriter = XmlDictionaryWriter.CreateTextWriter(stream, Encoding.UTF8, false))

Channels\TextMessageEncodingBindingElementTest.cs (1)

20Assert.Equal<Encoding>(Encoding.UTF8, element.WriteEncoding);

ServiceModel\ChannelFactoryTest.cs (1)

28new TextMessageEncodingBindingElement(MessageVersion.Default, Encoding.UTF8),

System\Text\Json\Document\JsonElement.cs (1)

221throw new KeyNotFoundException(SR.Format(SR.Arg_KeyNotFoundWithKey, Encoding.UTF8.GetString(utf8PropertyName)));

System\Text\Json\JsonHelpers.cs (1)

210int charsWritten = Encoding.UTF8.GetChars(utf8Key, charBuffer);

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

28return Encoding.UTF8.GetString(output.WrittenSpan); 61return Encoding.UTF8.GetString(output.WrittenSpan);

System\Text\Json\Serialization\Converters\FSharp\FSharpTypeConverterFactory.cs (1)

95byte[] utf8EncodedName = System.Text.Encoding.UTF8.GetBytes(typeDiscriminatorPropertyName);

System\Text\Json\Serialization\JsonSerializer.Read.HandlePropertyName.cs (2)

47string stringPropertyName = Encoding.UTF8.GetString(unescapedPropertyName); 54state.Current.JsonPropertyNameAsString = Encoding.UTF8.GetString(unescapedPropertyName);

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

709public byte[] NameAsUtf8Bytes { get; } = Encoding.UTF8.GetBytes(name);

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

485NameAsUtf8Bytes = Encoding.UTF8.GetBytes(Name);

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

83byte[] utf8EncodedName = Encoding.UTF8.GetBytes(propertyName);

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

372propertyName = Encoding.UTF8.GetString(utf8PropertyName);

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

378string message = GetResourceString(ref json, resource, nextByte, Encoding.UTF8.GetString(bytes));

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

369string name = Encoding.UTF8.GetString(nameBytes); 808ThrowJsonException(SR.Format(SR.DuplicateMetadataProperty, Encoding.UTF8.GetString(utf8PropertyName)));

JsonSourceGenerator.Parser.cs (1)

3192byte[] utf8Json = Encoding.UTF8.GetBytes(effectiveJsonPropertyName);

src\runtime\src\libraries\Common\src\SourceGenerators\SourceWriter.cs (1)

67return SourceText.From(_sb.ToString(), Encoding.UTF8);

RegexGenerator.Emitter.cs (1)

5578return $"{prefix}{ToHexStringNoDashes(sha.ComputeHash(Encoding.UTF8.GetBytes(toEncode)))}";

System\Web\HttpUtility.cs (5)

81public static NameValueCollection ParseQueryString(string query) => ParseQueryString(query, Encoding.UTF8); 161public static string? UrlEncode(string? str) => UrlEncode(str, Encoding.UTF8); 177public static byte[]? UrlEncodeToBytes(string? str) => UrlEncodeToBytes(str, Encoding.UTF8); 187public static string? UrlDecode(string? str) => UrlDecode(str, Encoding.UTF8); 193public static byte[]? UrlDecodeToBytes(string? str) => UrlDecodeToBytes(str, Encoding.UTF8);

System\Web\Util\HttpEncoder.cs (2)

570byte[] bytes = ArrayPool<byte>.Shared.Rent(Encoding.UTF8.GetMaxByteCount(toEncode.Length)); 571int utf8Length = Encoding.UTF8.GetBytes(toEncode, bytes);

System\Resources\ResXResourceWriter.cs (2)

161_xmlTextWriter = new XmlTextWriter(_stream, Encoding.UTF8); 166_xmlTextWriter = new XmlTextWriter(_fileName, Encoding.UTF8);

System\Windows\Forms\Controls\DataGridView\DataGridView.Methods.cs (2)

8153byte[] destinationBytes = Encoding.Convert(Encoding.Unicode, Encoding.UTF8, sourceBytes); 8177destinationBytes = Encoding.Convert(Encoding.Unicode, Encoding.UTF8, sourceBytes);

System\Windows\Forms\Controls\RichTextBox\RichTextBox.cs (3)

2920encodedBytes = (CodePagesEncodingProvider.Instance.GetEncoding(0) ?? Encoding.UTF8).GetBytes(str); 2964string str = (CodePagesEncodingProvider.Instance.GetEncoding(0) ?? Encoding.UTF8).GetString(bytes); 3052result = (CodePagesEncodingProvider.Instance.GetEncoding(0) ?? Encoding.UTF8).GetString(bytes, 0, bytes.Length);

System\Windows\Forms\Controls\WebBrowser\WebBrowser.cs (1)

325StreamWriter sw = new(ms, Encoding.UTF8);

TestData.cs (1)

50{ Encoding.UTF8 },

src\roslyn\src\Compilers\Shared\BuildServerConnection.cs (1)

703var bytes = sha.ComputeHash(Encoding.UTF8.GetBytes(pipeNameInput));

src\roslyn\src\Compilers\Shared\CompilerServerLogger.cs (1)

155byte[] bytes = Encoding.UTF8.GetBytes(output);

src\roslyn\src\Compilers\Server\VBCSCompiler\CompilationCache.cs (3)

123var bytes = SHA256.HashData(Encoding.UTF8.GetBytes(deterministicKey)); 276var oldKey = File.ReadAllText(keyPath, Encoding.UTF8); 331File.WriteAllText(Path.Combine(stagingDir, dllName + ".key"), deterministicKey, Encoding.UTF8);

src\roslyn\src\Compilers\Shared\BuildServerConnection.cs (1)

703var bytes = sha.ComputeHash(Encoding.UTF8.GetBytes(pipeNameInput));

src\roslyn\src\Compilers\Shared\CompilerServerLogger.cs (1)

155byte[] bytes = Encoding.UTF8.GetBytes(output);

CommandLine\AssemblyMetadataProvider.cs (1)

157var result = Encoding.UTF8.GetString(metadataReader.GetBlobBytes(attr.Value));

Processors\RunSettingsArgumentProcessor.cs (1)

166return XmlReader.Create(new StringReader(File.ReadAllText(runSettingsFile, Encoding.UTF8)), XmlRunSettingsUtilities.ReaderSettings);

Program.cs (1)

29Console.OutputEncoding = Encoding.UTF8;

src\vstest\src\vstest.console\CommandLine\AssemblyMetadataProvider.cs (1)

157var result = Encoding.UTF8.GetString(metadataReader.GetBlobBytes(attr.Value));

src\vstest\src\vstest.console\Processors\RunSettingsArgumentProcessor.cs (1)

166return XmlReader.Create(new StringReader(File.ReadAllText(runSettingsFile, Encoding.UTF8)), XmlRunSettingsUtilities.ReaderSettings);

src\vstest\src\vstest.console\Program.cs (1)

29Console.OutputEncoding = Encoding.UTF8;