Encoding

FrameworkFork\Microsoft.Xml\Xml\XmlEncoding.cs (1)

213internal class Ucs4Encoding : Encoding

FrameworkFork\System.Runtime.Serialization\System\Text\Base64Encoding.cs (1)

14internal class Base64Encoding : Encoding

FrameworkFork\System.Runtime.Serialization\System\Text\BinHexEncoding.cs (1)

11internal class BinHexEncoding : Encoding

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

24internal sealed class ConsoleEncoding : Encoding

System\Formats\Asn1\AsnCharacterStringEncodings.cs (2)

33internal abstract class SpanBasedEncoding : Encoding 365internal sealed class T61Encoding : Encoding

src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\ASCIIEncoding.cs (1)

23public partial class ASCIIEncoding : Encoding

src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\Latin1Encoding.cs (1)

16internal partial class Latin1Encoding : Encoding

src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\Latin1Encoding.Sealed.cs (1)

6internal partial class Latin1Encoding : Encoding

src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\UnicodeEncoding.cs (1)

19public class UnicodeEncoding : Encoding

src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\UTF32Encoding.cs (1)

22public sealed class UTF32Encoding : Encoding

src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\UTF7Encoding.cs (1)

14public class UTF7Encoding : Encoding

src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\UTF8Encoding.cs (1)

33public partial class UTF8Encoding : Encoding

System\Text\Base64Encoding.cs (1)

12internal sealed class Base64Encoding : Encoding

System\Text\BinHexEncoding.cs (1)

9internal sealed class BinHexEncoding : Encoding

System\Xml\XmlEncoding.cs (1)

212internal class Ucs4Encoding : Encoding

Internals\System\Text\BinHexEncoding.cs (1)

11internal class BinHexEncoding : Encoding

System\Text\EncodingNLS.cs (1)

24internal abstract class EncodingNLS : Encoding

Caching\DiskCache.cs (1)

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

Certificates\CertificateGeneration\CertificateManager.cs (5)

687pemEnvelope = Encoding.ASCII.GetBytes(pem); 703pemEnvelope = Encoding.ASCII.GetBytes(pem); 709bytes = Encoding.ASCII.GetBytes(PemEncoding.Write("CERTIFICATE", certificate.Export(X509ContentType.Cert))); 719bytes = Encoding.ASCII.GetBytes(PemEncoding.Write("CERTIFICATE", certificate.Export(X509ContentType.Cert))); 836bytePayload = Encoding.ASCII.GetBytes(AspNetHttpsOidFriendlyName);

Certificates\CertificateGeneration\UnixCertificateManager.cs (1)

686var encodedCommand = Convert.ToBase64String(System.Text.Encoding.Unicode.GetBytes(powershellScript));

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

79public void SetEncoding(Encoding encoding)

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

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

KafkaContainerFixture.cs (1)

66return container.CopyAsync(Encoding.Default.GetBytes(startupScript.ToString()), StartupScriptFilePath, fileMode: Unix.FileMode755, ct: ct);

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)

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

1842var keyBytes = Encoding.ASCII.GetBytes(keyPem); 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\BuildClient.cs (1)

105System.Text.Encoding.RegisterProvider(System.Text.CodePagesEncodingProvider.Instance);

src\roslyn\src\Compilers\Shared\BuildProtocol.cs (4)

138using var reader = new BinaryReader(inStream, Encoding.Unicode, leaveOpen: true); 163using var writer = new BinaryWriter(memoryStream, Encoding.Unicode); 286using (var writer = new BinaryWriter(memoryStream, Encoding.Unicode)) 334using (var reader = new BinaryReader(new MemoryStream(responseBuffer), Encoding.Unicode))

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\Shared\ConsoleUtil.cs (2)

14private static readonly Encoding s_utf8Encoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false); 22Encoding savedEncoding = Console.OutputEncoding;

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

AutomaticEncodingRestorer.cs (2)

17private readonly Encoding _originalOutputEncoding = null; 18private readonly Encoding _originalInputEncoding = null;

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

88Console.OutputEncoding = Encoding.UTF8; 94Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);

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

138using var reader = new BinaryReader(inStream, Encoding.Unicode, leaveOpen: true); 163using var writer = new BinaryWriter(memoryStream, Encoding.Unicode); 286using (var writer = new BinaryWriter(memoryStream, Encoding.Unicode)) 334using (var reader = new BinaryReader(new MemoryStream(responseBuffer), Encoding.Unicode))

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

src\aspnetcore\src\Shared\CertificateGeneration\CertificateManager.cs (5)

690pemEnvelope = Encoding.ASCII.GetBytes(pem); 706pemEnvelope = Encoding.ASCII.GetBytes(pem); 712bytes = Encoding.ASCII.GetBytes(PemEncoding.Write("CERTIFICATE", certificate.Export(X509ContentType.Cert))); 722bytes = Encoding.ASCII.GetBytes(PemEncoding.Write("CERTIFICATE", certificate.Export(X509ContentType.Cert))); 839bytePayload = Encoding.ASCII.GetBytes(AspNetHttpsOidFriendlyName);

src\aspnetcore\src\Shared\CertificateGeneration\UnixCertificateManager.cs (1)

687var encodedCommand = Convert.ToBase64String(System.Text.Encoding.Unicode.GetBytes(powershellScript));

Commands\FormatCommandCommon.cs (1)

263Console.InputEncoding = Encoding.UTF8;

Formatters\CharsetFormatter.cs (11)

16private static Encoding Utf8 => new UTF8Encoding(encoderShouldEmitUTF8Identifier: false); 17private static Encoding Latin1 => Encoding.GetEncoding("iso-8859-1"); 33if (!TryGetCharset(analyzerConfigOptions, out var encoding) 44private static bool IsEncodingEquivalent(SourceText sourceText, Encoding encoding) 59private static byte[] GetEncodedBytes(string text, Encoding encoding) 69private static bool TryGetCharset(AnalyzerConfigOptions analyzerConfigOptions, [NotNullWhen(true)] out Encoding? encoding) 83public static Encoding GetCharset(string charsetOption) 88"utf-8-bom" => Encoding.UTF8,// UTF-8 with BOM Marker 89"utf-16be" => Encoding.BigEndianUnicode,// Big Endian with BOM Marker 90"utf-16le" => Encoding.Unicode,// Little Endian with BOM Marker

Workspaces\FolderWorkspace.cs (2)

13private static Encoding DefaultEncoding => new UTF8Encoding(encoderShouldEmitUTF8Identifier: false); 62private void SaveDocumentText(DocumentId id, string fullPath, SourceText newText, Encoding encoding)

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

AuthenticationHeaderProvider.cs (2)

18private readonly Encoding _encoding; 20public BasicAuthenticationHeaderValueProvider(string username, string password, Encoding encoding)

Program.cs (6)

74var authEncodingArg = new Option<Encoding>("--auth-encoding", "-e") 76CustomParser = arg => Encoding.GetEncoding(arg.Tokens.Single().Value), 111Encoding? authEncoding = parseResult.GetValue(authEncodingArg); 177Encoding? authEncoding, 184var authenticationHeader = (authMethod != null) ? GetAuthenticationHeader(authMethod, authEncoding ?? Encoding.ASCII, user!, password!) : null; 528private static AuthenticationHeaderValue GetAuthenticationHeader(string method, Encoding encoding, string username, string password)

FileSuggestionRegistration.cs (2)

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

CmdCredentialsProvider.cs (1)

311return Encoding.Unicode.GetString(cert.GetCertHash());

CodeDomFixup\MethodCreationHelper.cs (6)

1462new CodeTypeReferenceExpression(typeof(Encoding)), 1504new CodeTypeReferenceExpression(typeof(Encoding)), 1617private static string GetEncoding(Encoding encoding) 1619if (encoding.WebName == Encoding.UTF8.WebName) 1623else if (encoding.WebName == Encoding.Unicode.WebName) 1627else if (encoding.WebName == Encoding.BigEndianUnicode.WebName)

CodeSerializer.cs (1)

23private static readonly Encoding s_ouputEncoding = new System.Text.UTF8Encoding(true);

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

56public override Encoding Encoding

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

713using (StreamWriter sw = new StreamWriter(temp, Encoding.UTF8)) 3928string[] lines = ReadAllLines(outputFile, Encoding.UTF8, FileShare.ReadWrite); 3952private static string[] ReadAllLines(String file, Encoding encoding, FileShare share) 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\BinaryXml\XmlBinaryReader.cs (8)

341private Encoding _unicode; 348_unicode = System.Text.Encoding.Unicode; 4015Encoding enc = System.Text.Encoding.GetEncoding(codepage); 4162Encoding enc = System.Text.Encoding.GetEncoding(codepage); 4339Encoding enc = System.Text.Encoding.GetEncoding(codepage);

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

49protected Encoding encoding; 172this.encoding = (Encoding)settings.Encoding.Clone();

FrameworkFork\Microsoft.Xml\Xml\Core\XmlParserContext.cs (4)

25private Encoding _encoding = null; 33public XmlParserContext(XmlNameTable nt, XmlNamespaceManager nsMgr, String xmlLang, XmlSpace xmlSpace, Encoding enc) 49String xmlLang, XmlSpace xmlSpace, Encoding enc) 190public Encoding Encoding

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

1718internal static Encoding GetEncoding(XmlReader reader)

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

391public Encoding Encoding

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

225private Encoding _reportedEncoding; 515Encoding enc = (context != null) ? context.Encoding : null; 544InitStringInput(string.Empty, Encoding.Unicode, xmlFragment); 549InitStringInput(context.BaseURI, Encoding.Unicode, xmlFragment); 563InitStringInput((context == null) ? string.Empty : context.BaseURI, Encoding.Unicode, string.Concat("<?xml ", xmlFragment, "?>")); 670Encoding enc = null; 745Encoding enc = null; 823InitStringInput(string.Empty, Encoding.Unicode, xmlFragment); 2091internal Encoding Encoding 2693InitStringInput(baseUri, Encoding.Unicode, internalDtd); 2874private void InitStreamInput(Stream stream, Encoding encoding) 2879private void InitStreamInput(string baseUriStr, Stream stream, Encoding encoding) 2885private void InitStreamInput(Uri baseUri, Stream stream, Encoding encoding) 2891private void InitStreamInput(Uri baseUri, string baseUriStr, Stream stream, Encoding encoding) 2896private void InitStreamInput(Uri baseUri, string baseUriStr, Stream stream, byte[] bytes, int byteCount, Encoding encoding) 3012_ps.encoding = Encoding.Unicode; 3020private void InitStringInput(string baseUriStr, Encoding originalEncoding, string str) 3164private Encoding DetectEncoding() 3198return Encoding.BigEndianUnicode; 3207return Encoding.Unicode; 3216return Encoding.Unicode; 3225return Encoding.BigEndianUnicode; 3247private void SetupEncoding(Encoding encoding) 3252_ps.encoding = Encoding.UTF8; 3275private void SwitchEncoding(Encoding newEncoding) 3289private Encoding CheckEncoding(string newEncodingName) 3318Encoding newEncoding = null; 3327newEncoding = Encoding.GetEncoding(newEncodingName); 3665Encoding encoding = null; 8158Encoding enc = _ps.encoding; 8175Encoding enc = _ps.encoding;

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

36internal Encoding encoding;

FrameworkFork\Microsoft.Xml\Xml\Core\XmlTextWriter.cs (3)

138private Encoding _encoding; 275public XmlTextWriter(Stream w, Encoding encoding) : this() 289public XmlTextWriter(String filename, Encoding encoding)

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

50protected Encoding encoding;

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

339public Encoding Encoding

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

441internal Encoding Encoding

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

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

FrameworkFork\Microsoft.Xml\Xml\Dom\XmlDocument.cs (2)

1292internal Encoding TextEncoding 1301return System.Text.Encoding.GetEncoding(value);

FrameworkFork\Microsoft.Xml\Xml\Dom\XmlDomTextWriter.cs (2)

17public XmlDOMTextWriter(Stream w, Encoding encoding) : base(w, encoding) 23public XmlDOMTextWriter(String filename, Encoding encoding) : base(filename, encoding)

FrameworkFork\Microsoft.Xml\Xml\Resolvers\XmlPreloadedResolver.cs (1)

107return new MemoryStream(Encoding.Unicode.GetBytes(_str));

FrameworkFork\Microsoft.Xml\Xml\XmlEncoding.cs (4)

286internal static Encoding UCS4_Littleendian 294internal static Encoding UCS4_Bigendian 302internal static Encoding UCS4_2143 309internal static Encoding UCS4_3412

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

40private Encoding _encoding; 54public EncodingStreamWrapper(Stream stream, Encoding encoding) 122private static Encoding GetEncoding(SupportedEncoding e) 140private static Encoding GetSafeEncoding(SupportedEncoding e) 176private static SupportedEncoding GetSupportedEncoding(Encoding encoding) 191public EncodingStreamWrapper(Stream stream, Encoding encoding, bool emitBOM) 470internal static ArraySegment<byte> ProcessBuffer(byte[] buffer, int offset, int count, Encoding encoding) 491Encoding localEnc; 640_byteCount = Encoding.UTF8.GetBytes(_chars, 0, charCount, _bytes, 0);

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

1367private int ReadBytes(Encoding encoding, int byteBlock, int charBlock, byte[] buffer, int offset, int byteCount, bool readContent)

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

99static public XmlDictionaryReader CreateTextReader(Stream stream, Encoding encoding,

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

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

FrameworkFork\System.Runtime.Serialization\System\Xml\XmlDictionaryWriter.cs (3)

43private static readonly Encoding s_UTF8Encoding = new UTF8Encoding(false); 49static public XmlDictionaryWriter CreateTextWriter(Stream stream, Encoding encoding) 54static public XmlDictionaryWriter CreateTextWriter(Stream stream, Encoding encoding, bool ownsStream)

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

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

23private Encoding _encoding; 31protected void SetOutput(Stream stream, bool ownsStream, Encoding encoding)

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

26void SetInput(byte[] buffer, int offset, int count, Encoding encoding, XmlDictionaryReaderQuotas quotas, OnXmlDictionaryReaderClose onClose); 27void SetInput(Stream stream, Encoding encoding, XmlDictionaryReaderQuotas quotas, OnXmlDictionaryReaderClose onClose); 562public void SetInput(byte[] buffer, int offset, int count, Encoding encoding, XmlDictionaryReaderQuotas quotas, OnXmlDictionaryReaderClose onClose) 580public void SetInput(Stream stream, Encoding encoding, XmlDictionaryReaderQuotas quotas, OnXmlDictionaryReaderClose onClose) 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 (9)

16void SetOutput(Stream stream, Encoding encoding, bool ownsStream); 23public void SetOutput(Stream stream, Encoding encoding, bool ownsStream) 29if (encoding.WebName != Encoding.UTF8.WebName) 51private Encoding _encoding; 103new public void SetOutput(Stream stream, bool ownsStream, Encoding encoding) 105Encoding utf8Encoding = null; 106if (encoding != null && encoding == Encoding.UTF8) 116public Encoding Encoding 151if (_encoding.WebName == Encoding.BigEndianUnicode.WebName)

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

14private static Encoding s_asciiEncoding; 16private static Encoding AsciiEncoding 22s_asciiEncoding = Encoding.GetEncoding("ascii"); 31return ParseQueryString(query, Encoding.UTF8); 34public static NameValueCollection ParseQueryString(string query, Encoding encoding) 60return UrlEncode(str, Encoding.UTF8); 79return UrlEncodeSpaces(UrlEncodeNonAscii(str, Encoding.UTF8)); 82public static string UrlEncode(string str, Encoding encoding) 140private static string UrlEncodeNonAscii(string str, Encoding e) 148e = Encoding.UTF8; 166public static byte[] UrlEncodeToBytes(string str, Encoding e) 176public static string UrlDecode(string str, Encoding e) 288private static string UrlDecodeStringFromStringInternal(string s, Encoding e) 416private Encoding _encoding; 427internal UrlDecoder(int bufferSize, Encoding encoding) 486internal HttpValueCollection(string str, Encoding encoding) 497internal void FillFromString(string s, bool urlencoded, Encoding encoding)

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

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

22private Encoding _writeEncoding; 30public MtomMessageEncodingBindingElement(MessageVersion messageVersion, Encoding writeEncoding) 123public Encoding WriteEncoding

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\TextMessageEncoder.cs (18)

28public TextMessageEncoderFactory(MessageVersion version, Encoding writeEncoding, int maxReadPoolSize, int maxWritePoolSize, XmlDictionaryReaderQuotas quotas) 53public static Encoding[] GetSupportedEncodings() 55Encoding[] supported = TextEncoderDefaults.SupportedEncodings; 56Encoding[] enc = new Encoding[supported.Length]; 92internal static string GetContentType(string mediaType, Encoding encoding) 99Encoding[] readEncodings = TextMessageEncoderFactory.GetSupportedEncodings(); 112internal static Encoding GetEncodingFromContentType(string contentType, ContentEncoding[] contentMap) 184Encoding enc; 229internal static bool TryGetEncodingFromCharSet(string charSet, out Encoding encoding) 241internal Encoding encoding; 257private Encoding _writeEncoding; 265public TextMessageEncoder(MessageVersion version, Encoding writeEncoding, int maxReadPoolSize, int maxWritePoolSize, XmlDictionaryReaderQuotas quotas) 309private static bool IsUTF8Encoding(Encoding encoding) 355Encoding tmp; 615private XmlReader TakeStreamedReader(Stream stream, Encoding enc) 681private Encoding _encoding; 691internal Encoding Encoding

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\TextMessageEncodingBindingElement.cs (3)

17private Encoding _writeEncoding; 24public TextMessageEncodingBindingElement(MessageVersion messageVersion, Encoding writeEncoding) 120public Encoding WriteEncoding

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

56public static readonly Encoding Encoding = Encoding.GetEncoding(TextEncoderDefaults.EncodingString); 58public static readonly Encoding[] SupportedEncodings = new Encoding[] { Encoding.UTF8, Encoding.Unicode, Encoding.BigEndianUnicode }; 63new CharSetEncoding("utf-8", Encoding.UTF8), 64new CharSetEncoding("utf-16LE", Encoding.Unicode), 65new CharSetEncoding("utf-16BE", Encoding.BigEndianUnicode), 70public static void ValidateEncoding(Encoding encoding) 73Encoding[] supportedEncodings = SupportedEncodings; 82public static string EncodingToCharSet(Encoding encoding) 88Encoding enc = charSetEncodings[i].Encoding; 98public static bool TryGetEncoding(string charSet, out Encoding encoding) 133public Encoding Encoding; 135public CharSetEncoding(string charSet, Encoding enc) 338public static Encoding TextEncoding

FrameworkFork\System.ServiceModel\System\ServiceModel\Description\MetadataExchangeClient.cs (4)

1270internal static Encoding GetRfcEncoding(string contentTypeStr) 1275internal static Encoding GetDictionaryReaderEncoding(string contentTypeStr) 1280Encoding encoding = GetRfcEncoding(contentTypeStr); 1286Encoding[] supportedEncodings = TextEncoderDefaults.SupportedEncodings;

FrameworkFork\System.ServiceModel\System\ServiceModel\HttpBindingBase.cs (1)

143public Encoding TextEncoding

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

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

140Encoding encoding = CanonicalFormWriter.Utf8WithoutPreamble;

FrameworkFork\System.ServiceModel\System\ServiceModel\UdpBinding.cs (1)

128public Encoding TextEncoding

FrameworkFork\System.ServiceModel\System\ServiceModel\WSHttpBindingBase.cs (1)

132public System.Text.Encoding TextEncoding

Metadata\MetadaExchangeResolver.cs (3)

272Encoding encoding = HttpWebRequestHelper.GetEncoding(webResponse.ContentType); 432public static Encoding GetEncoding(string contentType) 439return Encoding.GetEncoding(charset);

Metadata\ServiceDescriptor.cs (3)

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

Internal\SetCommand.cs (1)

67using (var writer = new StreamWriter(stream, Encoding.Unicode, 1024, true))

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

EventSourceGenerator.Parser.cs (1)

175byte[] bytes = Encoding.BigEndianUnicode.GetBytes(name);

CustomTextMessageEncoder.cs (1)

25_writerSettings.Encoding = Encoding.GetEncoding(factory.CharSet);

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

23private static readonly Encoding s_utf8Encoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true); 25private static readonly Lazy<Encoding> s_fallbackEncoding = new(CreateFallbackEncoding); 33internal static Encoding CreateFallbackEncoding() 41?? Encoding.GetEncoding(name: "Latin1"); 50Encoding.RegisterProvider(provider); 57internal static Encoding? TryGetCodePageEncoding(int codePage) 63return Encoding.GetEncoding(codePage); 73/// from <see cref="SourceText.From(Stream, Encoding, SourceHashAlgorithm, bool)"/> in two ways: 92Encoding? defaultEncoding = null, 104Lazy<Encoding> getEncoding, 105Encoding? defaultEncoding = null, 148Encoding encoding, 249internal static SourceText Create(Stream stream, Lazy<Encoding> getEncoding, Encoding defaultEncoding, SourceHashAlgorithm checksumAlgorithm, bool canBeEmbedded) 252internal static SourceText Decode(Stream data, Encoding encoding, SourceHashAlgorithm checksumAlgorithm, bool throwIfBinaryDetected, bool canBeEmbedded)

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

12internal static bool TryGetMaxCharCount(this Encoding encoding, long length, out int maxCharCount)

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

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

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

14private static readonly Encoding s_utf8bom = new UTF8Encoding(encoderShouldEmitUTF8Identifier: true);

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\EmbeddedLanguages\VirtualChars\VirtualCharSequenceSourceText.cs (2)

19public override Encoding? Encoding { get; } 21public VirtualCharSequenceSourceText(ImmutableSegmentedList<VirtualChar> virtualChars, Encoding? encoding)

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

47_reader = new BinaryReader(stream, Encoding.UTF8, leaveOpen); 219public Encoding? ReadEncoding() 228return Encoding.GetEncoding(ReadRequiredString()); 234return Encoding.GetEncoding(ReadInt32());

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

94_writer = new BinaryWriter(stream, Encoding.UTF8, leaveOpen); 517public void WriteEncoding(Encoding? encoding)

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

276/// Encoding serialized as <see cref="Encoding.WebName"/>. 287/// Encoding serialized as <see cref="Encoding.CodePage"/>.

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

Commands\GetDocumentCommandWorker.cs (2)

33private static readonly Encoding _utf8EncodingWithoutBOM 481private sealed class InvariantStreamWriter(Stream stream, Encoding? encoding = null, int bufferSize = -1, bool leaveOpen = false)

ProgramBase.cs (1)

28Console.OutputEncoding = Encoding.UTF8;

GrammarVisitor.cs (5)

585: Encoding.Unicode.GetString([.. VisitBytes(context.bytes()).Value]); 2519SerializationTypeCode.String => Encoding.Unicode.GetString(valueBytes), 2576return Encoding.UTF8.GetString(bytes.Slice(bytesRead, length)); 3122int byteCount = Encoding.UTF8.GetByteCount(str); 3130Encoding.UTF8.GetBytes(str, utf8Bytes);

VTableExportPEBuilder.cs (5)

420nameTableSize += Encoding.ASCII.GetByteCount(export.Name) + 1; 422int dllNameSize = Encoding.ASCII.GetByteCount(_dllName) + 1; 537nameOffset += Encoding.ASCII.GetByteCount(export.Name) + 1; 549byte[] nameBytes = Encoding.ASCII.GetBytes(export.Name); 555byte[] dllNameBytes = Encoding.ASCII.GetBytes(_dllName);

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

DumpNativeResources.cs (1)

195var hdr = new BinaryWriter(ms, System.Text.Encoding.Unicode);

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

32prefix = prefix.Append(System.Text.Encoding.ASCII.GetBytes(_targetSignature.GetStandaloneMethodSignatureCallingConventions().ToString("x")));

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

40builder.EmitBytes(Encoding.ASCII.GetBytes(compilerIdentifier));

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

FacebookHandler.cs (2)

69var key = Encoding.ASCII.GetBytes(Options.AppSecret); 70var tokenBytes = Encoding.ASCII.GetBytes(accessToken);

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

TwitterHandler.cs (2)

347var key = Encoding.ASCII.GetBytes( 352var hash = HMACSHA1.HashData(key, Encoding.ASCII.GetBytes(signatureData));

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

23public override Encoding Encoding => Encoding.UTF8;

Rendering\CacheViewTextWriter.cs (1)

34public override Encoding Encoding => _innerWriter.Encoding;

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

src\aspnetcore\src\submodules\MessagePack-CSharp\src\MessagePack.UnityClient\Assets\Scripts\MessagePack\StringEncoding.cs (1)

14internal static readonly Encoding UTF8 = new UTF8Encoding(false);

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\CertificateGeneration\CertificateManager.cs (5)

690pemEnvelope = Encoding.ASCII.GetBytes(pem); 706pemEnvelope = Encoding.ASCII.GetBytes(pem); 712bytes = Encoding.ASCII.GetBytes(PemEncoding.Write("CERTIFICATE", certificate.Export(X509ContentType.Cert))); 722bytes = Encoding.ASCII.GetBytes(PemEncoding.Write("CERTIFICATE", certificate.Export(X509ContentType.Cert))); 839bytePayload = Encoding.ASCII.GetBytes(AspNetHttpsOidFriendlyName);

src\aspnetcore\src\Shared\CertificateGeneration\UnixCertificateManager.cs (1)

687var encodedCommand = Convert.ToBase64String(System.Text.Encoding.Unicode.GetBytes(powershellScript));

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

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

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

21private static readonly Encoding UTF8NoBOM = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);

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

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

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

21private static readonly Encoding UTF8NoBOM = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: 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 (9)

56public static (Stream stream, bool usesTranscodingStream) GetStream(Stream innerStream, Encoding? encoding) 58if (encoding == null || encoding.CodePage == Encoding.UTF8.CodePage) 63var stream = Encoding.CreateTranscodingStream(innerStream, encoding, Encoding.UTF8, leaveOpen: true); 67public static Encoding? GetEncodingFromCharset(StringSegment charset) 73return Encoding.UTF8; 79return charset.HasValue ? Encoding.GetEncoding(charset.Value) : null; 87public static async ValueTask SendErrorResponse(HttpResponse response, Encoding encoding, Metadata trailers, Status status, JsonSerializerOptions options) 166public static async ValueTask WriteResponseMessage(HttpResponse response, Encoding encoding, object responseBody, JsonSerializerOptions options, CancellationToken cancellationToken)

Internal\JsonTranscodingServerCallContext.cs (3)

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

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

21private static readonly Encoding UTF8NoBOM = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);

Features\FormFeature.cs (4)

214var encoding = FilterEncoding(contentType.Encoding); 334private static Encoding FilterEncoding(Encoding? encoding) 340return Encoding.UTF8;

src\aspnetcore\src\Shared\HttpRuleParser.cs (2)

51internal static readonly Encoding DefaultHttpEncoding = Encoding.GetEncoding("iso-8859-1");

Extensions\HttpResponseWritingExtensions.cs (7)

31return response.WriteAsync(text, Encoding.UTF8, cancellationToken); 43public static Task WriteAsync(this HttpResponse response, string text, Encoding encoding, CancellationToken cancellationToken = default(CancellationToken)) 64private static async Task StartAndWriteAsyncAwaited(this HttpResponse response, string text, Encoding encoding, CancellationToken cancellationToken, Task startAsyncTask) 71private static void Write(this HttpResponse response, string text, Encoding encoding) 90private static int GetEncodingMaxByteSize(Encoding encoding) 92if (encoding == Encoding.UTF8) 100private static void WriteMultiSegmentEncoded(PipeWriter writer, string text, Encoding encoding, Span<byte> destination, int encodedLength, int minimumByteSize)

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

31public override Encoding Encoding => _utf8NoBom;

HttpRequestJsonExtensions.cs (23)

74var encoding = GetEncodingFromCharset(charset); 80if (encoding == null || encoding.CodePage == Encoding.UTF8.CodePage) 93inputStream = Encoding.CreateTranscodingStream(request.Body, encoding, Encoding.UTF8, leaveOpen: true); 130var encoding = GetEncodingFromCharset(charset); 136if (encoding == null || encoding.CodePage == Encoding.UTF8.CodePage) 149inputStream = Encoding.CreateTranscodingStream(request.Body, encoding, Encoding.UTF8, leaveOpen: true); 186var encoding = GetEncodingFromCharset(charset); 192if (encoding == null || encoding.CodePage == Encoding.UTF8.CodePage) 205inputStream = Encoding.CreateTranscodingStream(request.Body, encoding, Encoding.UTF8, leaveOpen: true); 266var encoding = GetEncodingFromCharset(charset); 272if (encoding == null || encoding.CodePage == Encoding.UTF8.CodePage) 285inputStream = Encoding.CreateTranscodingStream(request.Body, encoding, Encoding.UTF8, leaveOpen: true); 326var encoding = GetEncodingFromCharset(charset); 332if (encoding == null || encoding.CodePage == Encoding.UTF8.CodePage) 345inputStream = Encoding.CreateTranscodingStream(request.Body, encoding, Encoding.UTF8, leaveOpen: true); 409private static Encoding? GetEncodingFromCharset(StringSegment charset) 415return Encoding.UTF8; 421return charset.HasValue ? Encoding.GetEncoding(charset.Value) : null;

SessionExtensions.cs (2)

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

HttpResultsHelper.cs (3)

21private static readonly Encoding DefaultEncoding = Encoding.UTF8; 82out var resolvedContentTypeEncoding);

Results.cs (8)

87/// This is equivalent to <see cref="Text(string?, string?, Encoding?)"/>. 98public static IResult Content(string? content, string? contentType, Encoding? contentEncoding) 104/// This is equivalent to <see cref="Text(string?, string?, Encoding?, int?)"/>. 116public static IResult Content(string? content, string? contentType = null, Encoding? contentEncoding = null, int? statusCode = null) 122/// This is an alias for <see cref="Content(string?, string?, Encoding?)"/>. 133public static IResult Text(string? content, string? contentType, Encoding? contentEncoding) 139/// This is an alias for <see cref="Content(string?, string?, Encoding?, int?)"/>. 151public static IResult Text(string? content, string? contentType = null, Encoding? contentEncoding = null, int? statusCode = null)

src\aspnetcore\src\Shared\ResponseContentTypeHelper.cs (6)

29(string defaultContentType, Encoding defaultEncoding) @default, 30Func<string, Encoding?> getEncoding, 32out Encoding resolvedContentTypeEncoding) 40var actionResultEncoding = getEncoding(actionResultContentType); 48var mediaTypeEncoding = getEncoding(httpResponseContentType); 68public static Encoding? GetEncoding(string mediaType)

TypedResults.cs (8)

91/// This is equivalent to <see cref="Text(string?, string?, Encoding?)"/>. 102public static ContentHttpResult Content(string? content, string? contentType, Encoding? contentEncoding) 108/// This is equivalent to <see cref="Text(string?, string?, Encoding?, int?)"/>. 120public static ContentHttpResult Content(string? content, string? contentType = null, Encoding? contentEncoding = null, int? statusCode = null) 126/// This is an alias for <see cref="Content(string?, string?, Encoding?)"/>. 137public static ContentHttpResult Text(string? content, string? contentType, Encoding? contentEncoding) 153/// This is an alias for <see cref="Content(string?, string?, Encoding?, int?)"/>. 165public static ContentHttpResult Text(string? content, string? contentType = null, Encoding? contentEncoding = null, int? statusCode = null)

BufferingStream.cs (1)

50public string GetString(Encoding encoding)

HttpLoggingMiddleware.cs (1)

165out var encoding))

MediaTypeHelpers.cs (7)

13private static readonly List<Encoding> SupportedEncodings = new List<Encoding>() 15Encoding.UTF8, 16Encoding.Unicode, 17Encoding.ASCII, 18Encoding.Latin1 // TODO allowed by default? Make this configurable? 22public static bool TryGetEncodingForMediaType(string? contentType, List<MediaTypeState> mediaTypeList, [NotNullWhen(true)] out Encoding? encoding)

MediaTypeOptions.cs (8)

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; 62public void AddText(string contentType, Encoding encoding) 108public Encoding? Encoding { get; init; }

RequestBufferingStream.cs (2)

12private readonly Encoding _encoding; 20public RequestBufferingStream(Stream innerStream, int limit, ILogger logger, Encoding encoding, bool logOnFinish)

ResponseBufferingStream.cs (1)

24private Encoding? _encoding;

DataProtectorTokenProvider.cs (1)

198internal static readonly Encoding DefaultEncoding = new UTF8Encoding(false, true);

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

HttpClientSlim.cs (3)

35using (var writer = new StreamWriter(stream, Encoding.ASCII, bufferSize: 1024, leaveOpen: true)) 78using (var writer = new StreamWriter(stream, Encoding.ASCII, bufferSize: 1024, leaveOpen: true)) 96using (var reader = new StreamReader(stream, Encoding.ASCII, detectEncodingFromByteOrderMarks: true,

Formatters\InputFormatterContext.cs (3)

36Func<Stream, Encoding, TextReader> readerFactory) 65Func<Stream, Encoding, TextReader> readerFactory, 120public Func<Stream, Encoding, TextReader> ReaderFactory { get; }

Formatters\OutputFormatterWriteContext.cs (2)

21public OutputFormatterWriteContext(HttpContext httpContext, Func<Stream, Encoding, TextWriter> writerFactory, Type? objectType, object? @object) 50public virtual Func<Stream, Encoding, TextWriter> WriterFactory { get; protected set; }

ControllerBase.cs (1)

270public virtual ContentResult Content(string content, string contentType, Encoding contentEncoding)

Formatters\MediaType.cs (7)

134/// Gets the <see cref="System.Text.Encoding"/> of the <see cref="MediaType"/> if it has one. 136public Encoding? Encoding => _mediaTypeHeaderValue.Encoding; 192public static string ReplaceEncoding(string mediaType, Encoding encoding) 205public static string ReplaceEncoding(StringSegment mediaType, Encoding encoding) 237public static Encoding? GetEncoding(string mediaType) 247public static Encoding? GetEncoding(StringSegment mediaType) 298private static string CreateMediaTypeWithEncoding(StringSegment mediaType, Encoding encoding)

Formatters\StringOutputFormatter.cs (3)

20SupportedEncodings.Add(Encoding.UTF8); 21SupportedEncodings.Add(Encoding.Unicode); 43public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding encoding)

Formatters\SystemTextJsonInputFormatter.cs (4)

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

Formatters\SystemTextJsonOutputFormatter.cs (6)

28SupportedEncodings.Add(Encoding.UTF8); 29SupportedEncodings.Add(Encoding.Unicode); 61public sealed override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) 86if (selectedEncoding.CodePage == Encoding.UTF8.CodePage) 107var transcodingStream = Encoding.CreateTranscodingStream(httpContext.Response.Body, selectedEncoding, Encoding.UTF8, leaveOpen: true);

Formatters\TextInputFormatter.cs (11)

18protected static readonly Encoding UTF8EncodingWithoutBOM 24protected static readonly Encoding UTF16EncodingLittleEndian 32public IList<Encoding> SupportedEncodings { get; } = new List<Encoding>(); 39var selectedEncoding = SelectCharacterEncoding(context); 58/// <param name="encoding">The <see cref="Encoding"/> used to read the request body.</param> 62Encoding encoding); 65/// Returns an <see cref="Encoding"/> based on <paramref name="context"/>'s 70/// An <see cref="Encoding"/> based on <paramref name="context"/>'s 73protected Encoding? SelectCharacterEncoding(InputFormatterContext context) 90var requestEncoding = requestMediaType.Encoding;

Formatters\TextOutputFormatter.cs (16)

26SupportedEncodings = new List<Encoding>(); 34public IList<Encoding> SupportedEncodings { get; } 45cache.Add(mediaType, MediaType.ReplaceEncoding(mediaType, Encoding.UTF8)); 58/// Determines the best <see cref="Encoding"/> amongst the supported encodings 63/// <returns>The <see cref="Encoding"/> to use when reading the request or writing the response.</returns> 64public virtual Encoding SelectCharacterEncoding(OutputFormatterWriteContext context) 76var encoding = MatchAcceptCharacterEncoding(acceptCharsetHeaderValues); 90var supportedEncoding = SupportedEncodings[i]; 122var selectedEncoding = SelectCharacterEncoding(context); 158$"{nameof(WriteResponseBodyAsync)}({nameof(OutputFormatterWriteContext)},{nameof(Encoding)})"); 167/// <param name="selectedEncoding">The <see cref="Encoding"/> that should be used to write the response.</param> 169public abstract Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding); 182private string GetMediaTypeWithCharset(string mediaType, Encoding encoding) 184if (string.Equals(encoding.WebName, Encoding.UTF8.WebName, StringComparison.OrdinalIgnoreCase) && 193private Encoding? MatchAcceptCharacterEncoding(IList<StringWithQualityHeaderValue> acceptCharsetHeaders) 205var encoding = SupportedEncodings[j];

Infrastructure\ContentResultExecutor.cs (2)

44(DefaultContentType, Encoding.UTF8), 47out var resolvedContentTypeEncoding);

Infrastructure\IHttpRequestStreamReaderFactory.cs (3)

19/// <param name="encoding">The <see cref="Encoding"/>, usually <see cref="Encoding.UTF8"/>.</param> 21TextReader CreateReader(Stream stream, Encoding encoding);

Infrastructure\IHttpResponseStreamWriterFactory.cs (3)

19/// <param name="encoding">The <see cref="Encoding"/>, usually <see cref="Encoding.UTF8"/>.</param> 21TextWriter CreateWriter(Stream stream, Encoding encoding);

Infrastructure\MemoryPoolHttpRequestStreamReaderFactory.cs (1)

46public TextReader CreateReader(Stream stream, Encoding encoding)

Infrastructure\MemoryPoolHttpResponseStreamWriterFactory.cs (1)

54public TextWriter CreateWriter(Stream stream, Encoding encoding)

Infrastructure\ObjectResultExecutor.cs (1)

56protected Func<Stream, Encoding, TextWriter> WriterFactory { get; }

Infrastructure\SystemTextJsonResultExecutor.cs (6)

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

ModelBinding\Binders\BodyModelBinder.cs (1)

23private readonly Func<Stream, Encoding, TextReader> _readerFactory;

src\aspnetcore\src\Shared\HttpRuleParser.cs (2)

51internal static readonly Encoding DefaultHttpEncoding = Encoding.GetEncoding("iso-8859-1");

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

224/// Gets the <see cref="System.Text.Encoding"/> of the <see cref="ReadOnlyMediaTypeHeaderValue"/> if it has one. 226public Encoding? Encoding => GetEncodingFromCharset(GetParameter("charset")); 331public static Encoding? GetEncoding(string mediaType) 341public static Encoding? GetEncoding(StringSegment mediaType) 347private static Encoding? GetEncodingFromCharset(StringSegment charset) 353return Encoding.UTF8; 361return charset.HasValue ? Encoding.GetEncoding(charset.Value) : null;

src\aspnetcore\src\Shared\ResponseContentTypeHelper.cs (6)

29(string defaultContentType, Encoding defaultEncoding) @default, 30Func<string, Encoding?> getEncoding, 32out Encoding resolvedContentTypeEncoding) 40var actionResultEncoding = getEncoding(actionResultContentType); 48var mediaTypeEncoding = getEncoding(httpResponseContentType); 68public static Encoding? GetEncoding(string mediaType)

XmlDataContractSerializerInputFormatter.cs (3)

99public override async Task<InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context, Encoding encoding) 184/// <param name="encoding">The <see cref="Encoding"/> used to read the stream.</param> 186protected virtual XmlReader CreateXmlReader(Stream readStream, Encoding encoding)

XmlDataContractSerializerOutputFormatter.cs (3)

68SupportedEncodings.Add(Encoding.UTF8); 69SupportedEncodings.Add(Encoding.Unicode); 213public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding)

XmlSerializerInputFormatter.cs (5)

83Encoding encoding) 195/// <param name="encoding">The <see cref="Encoding"/> used to read the stream.</param> 198protected virtual XmlReader CreateXmlReader(Stream readStream, Encoding encoding, Type type) 207/// <param name="encoding">The <see cref="Encoding"/> used to read the stream.</param> 209protected virtual XmlReader CreateXmlReader(Stream readStream, Encoding encoding)

XmlSerializerOutputFormatter.cs (3)

67SupportedEncodings.Add(Encoding.UTF8); 68SupportedEncodings.Add(Encoding.Unicode); 192public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding)

NewtonsoftJsonInputFormatter.cs (1)

96Encoding encoding)

NewtonsoftJsonOutputFormatter.cs (3)

69SupportedEncodings.Add(Encoding.UTF8); 70SupportedEncodings.Add(Encoding.Unicode); 134public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding)

NewtonsoftJsonPatchInputFormatter.cs (1)

63Encoding encoding)

NewtonsoftJsonResultExecutor.cs (3)

24Encoding = Encoding.UTF8 80(DefaultContentType, Encoding.UTF8), 83out var resolvedContentTypeEncoding);

src\aspnetcore\src\Shared\ResponseContentTypeHelper.cs (6)

29(string defaultContentType, Encoding defaultEncoding) @default, 30Func<string, Encoding?> getEncoding, 32out Encoding resolvedContentTypeEncoding) 40var actionResultEncoding = getEncoding(actionResultContentType); 48var mediaTypeEncoding = getEncoding(httpResponseContentType); 68public static Encoding? GetEncoding(string mediaType)

RuntimeViewCompiler.cs (1)

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

PageBase.cs (1)

238public virtual ContentResult Content(string content, string contentType, Encoding contentEncoding)

PageModel.cs (1)

570public virtual ContentResult Content(string content, string contentType, Encoding contentEncoding)

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

CacheTagHelper.cs (1)

222public override Encoding Encoding => Null.Encoding;

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

Buffers\PagedBufferedTextWriter.cs (1)

22public override Encoding Encoding => _inner.Encoding;

Buffers\ViewBufferTextWriter.cs (5)

29/// <param name="encoding">The <see cref="System.Text.Encoding"/>.</param> 30public ViewBufferTextWriter(ViewBuffer buffer, Encoding encoding) 43/// <param name="encoding">The <see cref="System.Text.Encoding"/>.</param> 48public ViewBufferTextWriter(ViewBuffer buffer, Encoding encoding, HtmlEncoder htmlEncoder, TextWriter inner) 62public override Encoding Encoding { get; }

DefaultEditorTemplates.cs (1)

462public override Encoding Encoding => Null.Encoding;

HtmlHelper.cs (1)

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

ViewComponentResultExecutor.cs (2)

89(ViewExecutor.DefaultContentType, Encoding.UTF8), 92out var resolvedContentTypeEncoding);

ViewExecutor.cs (2)

192(DefaultContentType, Encoding.UTF8), 195out var resolvedContentTypeEncoding);

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

31public override Encoding Encoding => _utf8NoBom;

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

306public override Encoding Encoding 310return Encoding.UTF8;

UrlActions\CustomResponseAction.cs (1)

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

src\aspnetcore\src\Shared\HttpRuleParser.cs (2)

51internal static readonly Encoding DefaultHttpEncoding = Encoding.GetEncoding("iso-8859-1");

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

224/// Gets the <see cref="System.Text.Encoding"/> of the <see cref="ReadOnlyMediaTypeHeaderValue"/> if it has one. 226public Encoding? Encoding => GetEncodingFromCharset(GetParameter("charset")); 331public static Encoding? GetEncoding(string mediaType) 341public static Encoding? GetEncoding(StringSegment mediaType) 347private static Encoding? GetEncodingFromCharset(StringSegment charset) 353return Encoding.UTF8; 361return charset.HasValue ? Encoding.GetEncoding(charset.Value) : null;

_generated\74\Windows.Win32.PCSTR.g.cs (1)

69 public override string ToString() => this.Value is null ? null : new string((sbyte*)this.Value, 0, this.Length, global::System.Text.Encoding.Default);

Helpers.cs (1)

22return new ArraySegment<byte>(Encoding.ASCII.GetBytes(size.ToString("X", CultureInfo.InvariantCulture) + "\r\n"));

HttpSysOptions.cs (2)

261/// Configures request headers to use <see cref="Encoding.Latin1"/> encoding. 264/// Defaults to <c>false</c>, in which case <see cref="Encoding.UTF8"/> will be used. />.

RequestProcessing\RequestContext.cs (1)

459PropertyInfoLength = (uint)System.Text.Encoding.Unicode.GetByteCount(destination.UrlPrefix)

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

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

17private static readonly Encoding UTF8 = new UTF8Encoding(

src\aspnetcore\src\Shared\ServerInfrastructure\StringUtilities.cs (2)

19public static string GetAsciiOrUTF8String(this ReadOnlySpan<byte> span, Encoding defaultEncoding) 75return Encoding.Latin1.GetString(span);

_generated\39\Windows.Win32.PCSTR.g.cs (1)

69 public override string ToString() => this.Value is null ? null : new string((sbyte*)this.Value, 0, this.Length, global::System.Text.Encoding.Default);

Core\IISHttpContext.cs (4)

667var headerValueBytes = Encoding.UTF8.GetBytes(headerValue); 673var headerNameBytes = Encoding.UTF8.GetBytes(headerPair.Key); 700var headerNameBytes = Encoding.ASCII.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);

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

17private static readonly Encoding UTF8 = new UTF8Encoding(

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

21private static readonly Encoding UTF8NoBOM = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);

src\aspnetcore\src\Shared\ServerInfrastructure\BufferExtensions.cs (4)

122Encoding.ASCII.GetBytes(data, dest); 127WriteEncodedMultiWrite(ref buffer, data, sourceLength, Encoding.ASCII); 191internal static void WriteEncoded(ref this BufferWriter<PipeWriter> buffer, string data, Encoding encoding) 213private static void WriteEncodedMultiWrite(ref this BufferWriter<PipeWriter> buffer, string data, int encodedLength, Encoding encoding)

src\aspnetcore\src\Shared\ServerInfrastructure\StringUtilities.cs (2)

19public static string GetAsciiOrUTF8String(this ReadOnlySpan<byte> span, Encoding defaultEncoding) 75return Encoding.Latin1.GetString(span);

Internal\Http\DateHeaderValueManager.cs (1)

49Encoding.ASCII.GetBytes(dateValue, dateBytes.AsSpan(DatePreambleBytes.Length));

Internal\Http\Http1Connection.cs (1)

710Encoding.ASCII.GetBytes(absolutePath, pathBufferSliced);

Internal\Http\HttpHeaders.cs (1)

277public static void ValidateHeaderValueCharacters(string headerName, StringValues headerValues, Func<string, Encoding?> encodingSelector)

Internal\Http\HttpHeaders.Generated.cs (4)

7781var customEncoding = ReferenceEquals(EncodingSelector, KestrelServerOptions.DefaultHeaderEncodingSelector) 7990var customEncoding = ReferenceEquals(EncodingSelector, KestrelServerOptions.DefaultHeaderEncodingSelector) 8159var customEncoding = ReferenceEquals(EncodingSelector, KestrelServerOptions.DefaultHeaderEncodingSelector) 15169var encoding = ReferenceEquals(EncodingSelector, KestrelServerOptions.DefaultHeaderEncodingSelector)

Internal\Http\HttpProtocol.cs (4)

35private static readonly byte[] _bytesConnectionClose = Encoding.ASCII.GetBytes("\r\nConnection: close"); 36private static readonly byte[] _bytesConnectionKeepAlive = Encoding.ASCII.GetBytes("\r\nConnection: keep-alive"); 37private static readonly byte[] _bytesTransferEncodingChunked = Encoding.ASCII.GetBytes("\r\nTransfer-Encoding: chunked"); 38private static readonly byte[] _bytesServer = Encoding.ASCII.GetBytes("\r\nServer: " + Constants.ServerName);

Internal\Http\HttpRequestHeaders.cs (3)

22public Func<string, Encoding?> EncodingSelector { get; set; } 24public HttpRequestHeaders(bool reuseHeaderValues = true, Func<string, Encoding?>? encodingSelector = null) 119private unsafe void AppendContentLengthCustomEncoding(ReadOnlySpan<byte> value, Encoding customEncoding)

Internal\Http\HttpResponseHeaders.cs (4)

21public Func<string, Encoding?> EncodingSelector { get; set; } 23public HttpResponseHeaders(Func<string, Encoding?>? encodingSelector = null) 75Func<string, Encoding?> encodingSelector) 79var encoding = encodingSelector(kv.Key);

Internal\Http\HttpResponseTrailers.cs (2)

14public Func<string, Encoding?> EncodingSelector { get; set; } 16public HttpResponseTrailers(Func<string, Encoding?>? encodingSelector = null)

Internal\Http\PathDecoder.cs (1)

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

Internal\Http\ReasonPhrases.cs (1)

92return Encoding.ASCII.GetBytes(statusCode.ToString(CultureInfo.InvariantCulture) + " " + reasonPhrase);

Internal\Http2\Http2Connection.cs (1)

589var responseBytes = InvalidHttp1xErrorResponseBytes ??= Encoding.ASCII.GetBytes(

Internal\Http3\Http3HeadersEnumerator.cs (1)

27public Func<string, Encoding?> EncodingSelector { get; set; } = KestrelServerOptions.DefaultHeaderEncodingSelector;

Internal\Http3\QPackHeaderWriter.cs (2)

83var valueEncoding = ReferenceEquals(headersEnumerator.EncodingSelector, KestrelServerOptions.DefaultHeaderEncodingSelector) 104private static bool EncodeHeader(Span<byte> buffer, int staticTableId, string name, string value, Encoding? valueEncoding, out int headerLength)

Internal\Infrastructure\HttpUtilities.cs (5)

116public static string GetRequestHeaderString(this ReadOnlySpan<byte> span, string name, Func<string, Encoding?> encodingSelector, bool checkForNewlineChars) 155private static string GetRequestHeaderStringWithoutDefaultEncodingCore(this ReadOnlySpan<byte> span, string name, Func<string, Encoding?> encodingSelector) 157var encoding = encodingSelector(name); 163if (ReferenceEquals(encoding, Encoding.Latin1)) 614var bytes = Encoding.ASCII.GetBytes($"\r\nAlt-Svc: " + text);

Internal\Infrastructure\KestrelEventSource.cs (2)

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

KestrelServerOptions.cs (7)

41internal static readonly Func<string, Encoding?> DefaultHeaderEncodingSelector = _ => null; 46private Func<string, Encoding?> _requestHeaderEncodingSelector = DefaultHeaderEncodingSelector; 48private Func<string, Encoding?> _responseHeaderEncodingSelector = DefaultHeaderEncodingSelector; 155/// Gets or sets a callback that returns the <see cref="Encoding"/> to decode the value for the specified request header name, 158public Func<string, Encoding?> RequestHeaderEncodingSelector 165/// Gets or sets a callback that returns the <see cref="Encoding"/> to encode the value for the specified response header 168public Func<string, Encoding?> ResponseHeaderEncodingSelector

src\aspnetcore\src\Servers\Kestrel\shared\HPackHeaderWriter.cs (1)

126var valueEncoding =

src\aspnetcore\src\Servers\Kestrel\shared\Http2HeadersEnumerator.cs (1)

40public Func<string, Encoding?> EncodingSelector { get; set; } = KestrelServerOptions.DefaultHeaderEncodingSelector;

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\CertificateGeneration\CertificateManager.cs (5)

690pemEnvelope = Encoding.ASCII.GetBytes(pem); 706pemEnvelope = Encoding.ASCII.GetBytes(pem); 712bytes = Encoding.ASCII.GetBytes(PemEncoding.Write("CERTIFICATE", certificate.Export(X509ContentType.Cert))); 722bytes = Encoding.ASCII.GetBytes(PemEncoding.Write("CERTIFICATE", certificate.Export(X509ContentType.Cert))); 839bytePayload = Encoding.ASCII.GetBytes(AspNetHttpsOidFriendlyName);

src\aspnetcore\src\Shared\CertificateGeneration\UnixCertificateManager.cs (1)

687var encodedCommand = Convert.ToBase64String(System.Text.Encoding.Unicode.GetBytes(powershellScript));

src\aspnetcore\src\Shared\Hpack\DynamicHPackEncoder.cs (2)

69Encoding? valueEncoding, out int bytesWritten) 118int headerLength, Encoding? valueEncoding, out int bytesWritten)

src\aspnetcore\src\Shared\runtime\Http2\Hpack\H2StaticTable.Http2.cs (2)

102Encoding.ASCII.GetBytes(name), 103value.Length != 0 ? Encoding.ASCII.GetBytes(value) : Array.Empty<byte>());

src\aspnetcore\src\Shared\runtime\Http2\Hpack\HeaderField.cs (2)

45return Encoding.Latin1.GetString(Name) + ": " + Encoding.Latin1.GetString(Value);

src\aspnetcore\src\Shared\runtime\Http2\Hpack\HPackEncoder.cs (12)

src\aspnetcore\src\Shared\runtime\Http2\Hpack\StatusCodes.cs (1)

145return Encoding.ASCII.GetBytes(statusCode.ToString(CultureInfo.InvariantCulture));

src\aspnetcore\src\Shared\runtime\Http3\QPack\H3StaticTable.Http3.cs (2)

142=> new HeaderField(Encoding.ASCII.GetBytes(name), Encoding.ASCII.GetBytes(value));

src\aspnetcore\src\Shared\runtime\Http3\QPack\HeaderField.cs (2)

35return Encoding.ASCII.GetString(Name) + ": " + Encoding.ASCII.GetString(Value);

src\aspnetcore\src\Shared\runtime\Http3\QPack\QPackEncoder.cs (9)

66public static bool EncodeLiteralHeaderFieldWithStaticNameReference(int index, string value, Encoding? valueEncoding, Span<byte> destination, out int bytesWritten) 89/// Encodes just the name part of a Literal Header Field With Static Name Reference. Must call <see cref="EncodeValueString(string, Encoding?, Span{byte}, out int)"/> after to encode the header's value. 130public static bool EncodeLiteralHeaderFieldWithoutNameReference(string name, string value, Encoding? valueEncoding, Span<byte> destination, out int bytesWritten) 147public static bool EncodeLiteralHeaderFieldWithoutNameReference(string name, ReadOnlySpan<string> values, byte[] separator, Encoding? valueEncoding, Span<byte> destination, out int bytesWritten) 160/// Encodes just the value part of a Literawl Header Field Without Static Name Reference. Must call <see cref="EncodeValueString(string, Encoding?, Span{byte}, out int)"/> after to encode the header's value. 182private static bool EncodeValueString(string s, Encoding? valueEncoding, Span<byte> buffer, out int length) 188int encodedStringLength = valueEncoding is null || ReferenceEquals(valueEncoding, Encoding.Latin1) 220public static bool EncodeValueString(ReadOnlySpan<string> values, byte[]? separator, Encoding? valueEncoding, Span<byte> buffer, out int length) 239if (valueEncoding is null || ReferenceEquals(valueEncoding, Encoding.Latin1))

src\aspnetcore\src\Shared\ServerInfrastructure\BufferExtensions.cs (4)

122Encoding.ASCII.GetBytes(data, dest); 127WriteEncodedMultiWrite(ref buffer, data, sourceLength, Encoding.ASCII); 191internal static void WriteEncoded(ref this BufferWriter<PipeWriter> buffer, string data, Encoding encoding) 213private static void WriteEncodedMultiWrite(ref this BufferWriter<PipeWriter> buffer, string data, int encodedLength, Encoding encoding)

src\aspnetcore\src\Shared\ServerInfrastructure\StringUtilities.cs (2)

19public static string GetAsciiOrUTF8String(this ReadOnlySpan<byte> span, Encoding defaultEncoding) 75return Encoding.Latin1.GetString(span);

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\ServerInfrastructure\StringUtilities.cs (2)

19public static string GetAsciiOrUTF8String(this ReadOnlySpan<byte> span, Encoding defaultEncoding) 75return Encoding.Latin1.GetString(span);

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

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

31public override Encoding Encoding => _utf8NoBom;

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

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

31public override Encoding Encoding => _utf8NoBom;

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

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

31public override Encoding Encoding => _utf8NoBom;

RedisHubLifetimeManager.cs (2)

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

37private readonly Encoding _encoding; 44: this(pipeReader, Encoding.UTF8) 52/// <param name="encoding">The <see cref="Encoding"/>.</param> 53public FormPipeReader(PipeReader pipeReader, Encoding encoding) 56if (encoding is Encoding { CodePage: 65000 }) 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 (3)

74: this(stream, Encoding.UTF8, ArrayPool<char>.Shared) 83public FormReader(Stream stream, Encoding encoding) 94public FormReader(Stream stream, Encoding encoding, ArrayPool<char> charPool)

HttpRequestStreamReader.cs (4)

19private readonly Encoding _encoding; 41public HttpRequestStreamReader(Stream stream, Encoding encoding) 52public HttpRequestStreamReader(Stream stream, Encoding encoding, int bufferSize) 67Encoding encoding,

HttpResponseStreamWriter.cs (5)

13/// Writes to the HTTP response <see cref="Stream"/> using the supplied <see cref="System.Text.Encoding"/>. 37public HttpResponseStreamWriter(Stream stream, Encoding encoding) 48public HttpResponseStreamWriter(Stream stream, Encoding encoding, int bufferSize) 63Encoding encoding, 103public override Encoding Encoding { get; }

MultipartBoundary.cs (1)

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

MultipartSectionStreamExtensions.cs (2)

39var streamEncoding = sectionMediaType?.Encoding; 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);

BackEnd\Node\OutOfProcServerNode.cs (1)

528public override Encoding Encoding => _internalWriter.Encoding;

Construction\ProjectRootElement.cs (7)

77private static readonly Encoding s_defaultEncoding = Encoding.UTF8; 105private Encoding _encoding; 469public Encoding Encoding 485_encoding = Encoding.GetEncoding(declaration.Encoding); 1534public void Save(Encoding saveEncoding) 1603public void Save(string path, Encoding encoding)

Construction\Solution\SolutionFile.cs (2)

554reader = new StreamReader(fileStream, Encoding.GetEncoding(0)); // HIGHCHAR: If solution files have no byte-order marks, then assume ANSI rather than ASCII. 745SolutionReader = new StreamReader(fileStream, Encoding.GetEncoding(0)); // HIGHCHAR: If solution files have no byte-order marks, then assume ANSI rather than ASCII.

Definition\Project.cs (2)

1448public void Save(Encoding encoding) 1465public void Save(string path, Encoding encoding)

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

45_encoding = Encoding.UTF8; 216_encoding = Encoding.GetEncoding(parameterValue); 276private Encoding _encoding = new UTF8Encoding(false);

Logging\TerminalLogger\Terminal.cs (3)

23private readonly Encoding _originalOutputEncoding; 92Console.OutputEncoding = Encoding.UTF8; 105_originalOutputEncoding = Encoding.UTF8;

ObjectModelRemoting\ConstructionObjectLinks\ProjectRootElementLink.cs (3)

56public abstract Encoding Encoding { get; } 189/// Facilitate remoting the <see cref="ProjectRootElement.Save(Encoding)"/>. 191public abstract void Save(Encoding saveEncoding);

src\msbuild\src\Shared\TaskLoggingHelper.cs (1)

1320using (StreamReader fileStream = FileUtilities.OpenRead(fileName, Encoding.GetEncoding(0))) // HIGHCHAR: Use ANSI for logging messages.

Utilities\EncodingStringWriter.cs (3)

24public EncodingStringWriter(Encoding encoding) : base(CultureInfo.InvariantCulture) 26Encoding = encoding ?? Encoding.UTF8; 32public override Encoding Encoding { get; }

Utilities\ProjectWriter.cs (2)

91internal ProjectWriter(string filename, Encoding encoding) 195private readonly Encoding _documentEncoding;

Xml\XmlReaderExtension.cs (8)

30private static readonly Encoding s_utf8NoBom = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false); 44Encoding detectedEncoding; 49Encoding.RegisterProvider(CodePagesEncodingProvider.Instance); 60var encodingFromAttribute = GetEncodingFromAttribute(Reader); 76internal Encoding Encoding { get; } 85private static XmlReader GetXmlReader(string file, StreamReader input, bool loadAsReadOnly, out Encoding encoding) 109private static Encoding GetEncodingFromAttribute(XmlReader reader) 114? Encoding.GetEncoding(encodingAttributeString)

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

28internal static readonly Encoding Utf8WithoutBom = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false); 30private static Encoding s_currentOemEncoding; 42internal static Encoding CurrentSystemOemEncoding 56s_currentOemEncoding = Encoding.UTF8; 96internal static bool SimilarToEncoding(this Encoding encoding1, Encoding encoding2) 121internal static bool IsUtf8Encoding(this Encoding encoding) 123return SimilarToEncoding(encoding, Encoding.UTF8); 133return StartsWithPreamble(stream, Encoding.UTF8.GetPreamble()); 200var systemEncoding = Encoding.GetEncoding(codePage, EncoderFallback.ExceptionFallback, 205var oemBytes = Encoding.Convert(unicodeEncoding, systemEncoding, unicodeBytes); 227internal static Encoding BatchFileEncoding(string contents, string encodingSpecification) 234var defaultEncoding = EncodingUtilities.CurrentSystemOemEncoding; 282Console.OutputEncoding = Encoding.UTF8; 284Console.InputEncoding = Encoding.UTF8;

FileUtilities.cs (2)

1602internal static StreamWriter OpenWrite(string path, bool append, Encoding? encoding = null) 1617internal static StreamReader OpenRead(string path, Encoding? encoding = null, bool detectEncodingFromByteOrderMarks = true)

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

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

src\roslyn\src\Compilers\Shared\BuildProtocol.cs (4)

138using var reader = new BinaryReader(inStream, Encoding.Unicode, leaveOpen: true); 163using var writer = new BinaryWriter(memoryStream, Encoding.Unicode); 286using (var writer = new BinaryWriter(memoryStream, Encoding.Unicode)) 334using (var reader = new BinaryReader(new MemoryStream(responseBuffer), Encoding.Unicode))

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\Shared\ConsoleUtil.cs (2)

14private static readonly Encoding s_utf8Encoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false); 22Encoding savedEncoding = Console.OutputEncoding;

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

Exec.cs (7)

57private Encoding _standardErrorEncoding; 58private Encoding _standardOutputEncoding; 128protected override Encoding StandardOutputEncoding => _standardOutputEncoding; 133protected override Encoding StandardErrorEncoding => _standardErrorEncoding; 146_standardOutputEncoding = Encoding.GetEncoding(value); 167_standardErrorEncoding = Encoding.GetEncoding(value); 200var encoding = EncodingUtilities.BatchFileEncoding(Command + _workingDirectory.Value, UseUtf8Encoding);

FileIO\WriteLinesToFile.cs (9)

22private static readonly Encoding s_defaultEncoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true); 108Encoding encoding = s_defaultEncoding; 113encoding = System.Text.Encoding.GetEncoding(Encoding); 137private bool ExecuteTransactional(AbsolutePath filePath, string directoryPath, string contentsAsString, Encoding encoding) 171private bool SaveAtomically(AbsolutePath filePath, string contentsAsString, Encoding encoding) 245private bool SaveAtomicallyAppend(AbsolutePath filePath, string directoryPath, string contentsAsString, Encoding encoding) 267private bool ShouldWriteFileForOverwrite(AbsolutePath filePath, string contentsAsString, Encoding encoding) 308/// account for the encoding preamble (BOM), because <see cref="System.IO.File.WriteAllText(string, string, Encoding)"/> 313private bool FilesAreIdentical(AbsolutePath filePath, string contentsAsString, Encoding encoding)

GenerateResource.cs (2)

3879using (StreamWriter writer = FileUtilities.OpenWrite(fileName, false, Encoding.UTF8)) 3975internal LineNumberStreamReader(Stream fileStream, Encoding encoding, bool detectEncoding)

Hash.cs (2)

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

253Encoding.RegisterProvider(CodePagesEncodingProvider.Instance); 258Encoding textFileEncoding = fileRefEncoding != null 259? Encoding.GetEncoding(fileRefEncoding) 260: Encoding.Default; 325using (var x = new MemoryStream(Encoding.UTF8.GetBytes(resxContent)))

src\msbuild\src\Shared\LanguageParser\StreamMappedString.cs (2)

115Encoding.ASCII, 121Encoding utf8Encoding = new UTF8Encoding(false, true /* throw on illegal bytes */);

GitDataReader\GitRefTableReader.cs (1)

19private static readonly Encoding s_utf8 = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);

src\msbuild\src\Shared\TaskLoggingHelper.cs (1)

1320using (StreamReader fileStream = FileUtilities.OpenRead(fileName, Encoding.GetEncoding(0))) // HIGHCHAR: Use ANSI for logging messages.

ToolTask.cs (6)

161private Encoding _encoding; 229protected virtual Encoding ResponseFileEncoding => Encoding.UTF8; 245protected virtual Encoding StandardOutputEncoding 267protected virtual Encoding StandardErrorEncoding 1534Encoding encoding;

CommandLine\CommandLineArguments.cs (1)

249public Encoding? Encoding { get; internal set; }

CommandLine\CommandLineParser.cs (1)

1218internal static Encoding? TryParseEncodingName(string arg)

CommandLine\CommonCompiler.cs (5)

75private readonly Lazy<Encoding> _fallbackEncoding = new Lazy<Encoding>(EncodedStringText.CreateFallbackEncoding); 351internal Encoding? GetFallbackEncoding() 369using (var reader = new StreamReader(data, Encoding.UTF8)) 1837var bytes = Encoding.UTF8.GetBytes(key);

Compilation\Compilation.cs (1)

2011var reader = new BinaryReader(win32Resources, Encoding.Unicode);

CryptographicHashProvider.cs (1)

266return Encoding.Unicode.GetBytes(constant.StringValue!);

CvtRes.cs (3)

54var reader = new BinaryReader(stream, Encoding.Unicode); 234var reader = new BinaryReader(stream, Encoding.Unicode); 513var resWriter = new BinaryWriter(resStream, Encoding.Unicode);

DiaSymReader\Writer\SymUnmanagedWriterImpl.cs (3)

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

Emit\EmitOptions.cs (6)

110public Encoding? DefaultSourceFileEncoding { get; private set; } 116public Encoding? FallbackSourceFileEncoding { get; private set; } 233Encoding? defaultSourceFileEncoding = null, 234Encoding? fallbackSourceFileEncoding = null) 536public EmitOptions WithDefaultSourceFileEncoding(Encoding? defaultSourceFileEncoding) 546public EmitOptions WithFallbackSourceFileEncoding(Encoding? fallbackSourceFileEncoding)

EncodedStringText.cs (15)

23private static readonly Encoding s_utf8Encoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true); 25private static readonly Lazy<Encoding> s_fallbackEncoding = new(CreateFallbackEncoding); 33internal static Encoding CreateFallbackEncoding() 41?? Encoding.GetEncoding(name: "Latin1"); 50Encoding.RegisterProvider(provider); 57internal static Encoding? TryGetCodePageEncoding(int codePage) 63return Encoding.GetEncoding(codePage); 73/// from <see cref="SourceText.From(Stream, Encoding, SourceHashAlgorithm, bool)"/> in two ways: 92Encoding? defaultEncoding = null, 104Lazy<Encoding> getEncoding, 105Encoding? defaultEncoding = null, 148Encoding encoding, 249internal static SourceText Create(Stream stream, Lazy<Encoding> getEncoding, Encoding defaultEncoding, SourceHashAlgorithm checksumAlgorithm, bool canBeEmbedded) 252internal static SourceText Decode(Stream data, Encoding encoding, SourceHashAlgorithm checksumAlgorithm, bool throwIfBinaryDetected, bool canBeEmbedded)

InternalUtilities\EncodingExtensions.cs (1)

12internal static bool TryGetMaxCharCount(this Encoding encoding, long length, out int maxCharCount)

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

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

321/// If an encoding-less <see cref="SourceText"/> is written to a file a <see cref="Encoding.UTF8"/> shall be used as a default. 327public SourceText GetText(Encoding? encoding = null, SourceHashAlgorithm checksumAlgorithm = SourceHashAlgorithm.Sha1)

Syntax\SyntaxTree.cs (1)

104public abstract Encoding? Encoding { get; }

Text\ChangedText.cs (1)

102public override Encoding? Encoding

Text\CompositeText.cs (5)

26private readonly Encoding? _encoding; 28private CompositeText(ImmutableArray<SourceText> segments, Encoding? encoding, SourceHashAlgorithm checksumAlgorithm) 52public override Encoding? Encoding 346var encoding = segments[i].Encoding; 402var encoding = segments[0].Encoding;

Text\LargeText.cs (6)

31private readonly Encoding? _encodingOpt; 33internal LargeText(ImmutableArray<char[]> chunks, Encoding? encodingOpt, ImmutableArray<byte> checksum, SourceHashAlgorithm checksumAlgorithm, ImmutableArray<byte> embeddedTextBlob) 50internal LargeText(ImmutableArray<char[]> chunks, Encoding? encodingOpt, SourceHashAlgorithm checksumAlgorithm) 55internal static SourceText Decode(Stream stream, Encoding encoding, SourceHashAlgorithm checksumAlgorithm, bool throwIfBinaryDetected, bool canBeEmbedded) 81internal static SourceText Decode(TextReader reader, int length, Encoding? encodingOpt, SourceHashAlgorithm checksumAlgorithm) 153public override Encoding? Encoding => _encodingOpt;

Text\LargeTextWriter.cs (3)

14private readonly Encoding? _encoding; 22public LargeTextWriter(Encoding? encoding, SourceHashAlgorithm checksumAlgorithm, int length) 37public override Encoding Encoding

Text\SourceText.cs (25)

50private static readonly Encoding s_utf8EncodingWithNoBOM = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: false); 100/// If an encoding-less <see cref="SourceText"/> is written to a file a <see cref="Encoding.UTF8"/> shall be used as a default. 107public static SourceText From(string text, Encoding? encoding = null, SourceHashAlgorithm checksumAlgorithm = SourceHashAlgorithm.Sha1) 126/// If an encoding-less <see cref="SourceText"/> is written to a file a <see cref="Encoding.UTF8"/> shall be used as a default. 136Encoding? encoding = null, 156public static SourceText From(Stream stream, Encoding? encoding, SourceHashAlgorithm checksumAlgorithm, bool throwIfBinaryDetected) 165/// <see cref="Encoding.UTF8"/> if not specified. 184Encoding? encoding = null, 227public static SourceText From(byte[] buffer, int length, Encoding? encoding, SourceHashAlgorithm checksumAlgorithm, bool throwIfBinaryDetected) 237/// <see cref="Encoding.UTF8"/> if not specified. 254Encoding? encoding = null, 292private static string Decode(Stream stream, Encoding encoding, out Encoding actualEncoding) 335private static string Decode(byte[] buffer, int length, Encoding encoding, out Encoding actualEncoding) 394/// If an encoding-less <see cref="SourceText"/> is written to a file a <see cref="Encoding.UTF8"/> shall be used as a default. 396public abstract Encoding? Encoding { get; } 426/// If this text was constructed via <see cref="From(byte[], int, Encoding, SourceHashAlgorithm, bool, bool)"/> or 427/// <see cref="From(Stream, Encoding, SourceHashAlgorithm, bool, bool)"/>, then the canBeEmbedded arg must have 1277internal static Encoding? TryReadByteOrderMark(byte[] source, int length, out int preambleLength) 1290return Encoding.BigEndianUnicode; 1299return Encoding.Unicode; 1308return Encoding.UTF8; 1348internal static int GetMaxCharCountOrThrowIfHuge(Encoding encoding, Stream stream) 1385public override Encoding? Encoding => _underlying.Encoding;

Text\SourceTextStream.cs (2)

19private readonly Encoding _encoding; 35private static readonly Encoding s_utf8EncodingWithNoBOM = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: false);

Text\SourceTextWriter.cs (1)

14public static SourceTextWriter Create(Encoding? encoding, SourceHashAlgorithm checksumAlgorithm, int length)

Text\StringBuilderText.cs (3)

22private readonly Encoding? _encodingOpt; 24public StringBuilderText(StringBuilder builder, Encoding? encodingOpt, SourceHashAlgorithm checksumAlgorithm) 33public override Encoding? Encoding

Text\StringText.cs (3)

21private readonly Encoding? _encodingOpt; 25Encoding? encodingOpt, 37public override Encoding? Encoding => _encodingOpt;

Text\StringTextWriter.cs (3)

20private readonly Encoding? _encoding; 23public StringTextWriter(Encoding? encoding, SourceHashAlgorithm checksumAlgorithm, int capacity) 31public override Encoding Encoding

Text\SubText.cs (1)

37public override Encoding? Encoding => UnderlyingText.Encoding;

src\roslyn\src\Compilers\Core\Portable\EncodedStringText.cs (15)

23private static readonly Encoding s_utf8Encoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true); 25private static readonly Lazy<Encoding> s_fallbackEncoding = new(CreateFallbackEncoding); 33internal static Encoding CreateFallbackEncoding() 41?? Encoding.GetEncoding(name: "Latin1"); 50Encoding.RegisterProvider(provider); 57internal static Encoding? TryGetCodePageEncoding(int codePage) 63return Encoding.GetEncoding(codePage); 73/// from <see cref="SourceText.From(Stream, Encoding, SourceHashAlgorithm, bool)"/> in two ways: 92Encoding? defaultEncoding = null, 104Lazy<Encoding> getEncoding, 105Encoding? defaultEncoding = null, 148Encoding encoding, 249internal static SourceText Create(Stream stream, Lazy<Encoding> getEncoding, Encoding defaultEncoding, SourceHashAlgorithm checksumAlgorithm, bool canBeEmbedded) 252internal static SourceText Decode(Stream data, Encoding encoding, SourceHashAlgorithm checksumAlgorithm, bool throwIfBinaryDetected, bool canBeEmbedded)

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

12internal static bool TryGetMaxCharCount(this Encoding encoding, long length, out int maxCharCount)

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

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

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

14private static readonly Encoding s_utf8bom = new UTF8Encoding(encoderShouldEmitUTF8Identifier: true);

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\EmbeddedLanguages\VirtualChars\VirtualCharSequenceSourceText.cs (2)

19public override Encoding? Encoding { get; } 21public VirtualCharSequenceSourceText(ImmutableSegmentedList<VirtualChar> virtualChars, Encoding? encoding)

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

47_reader = new BinaryReader(stream, Encoding.UTF8, leaveOpen); 219public Encoding? ReadEncoding() 228return Encoding.GetEncoding(ReadRequiredString()); 234return Encoding.GetEncoding(ReadInt32());

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

94_writer = new BinaryWriter(stream, Encoding.UTF8, leaveOpen); 517public void WriteEncoding(Encoding? encoding)

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

276/// Encoding serialized as <see cref="Encoding.WebName"/>. 287/// Encoding serialized as <see cref="Encoding.CodePage"/>.

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

src\roslyn\src\Compilers\Core\Portable\EncodedStringText.cs (15)

23private static readonly Encoding s_utf8Encoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true); 25private static readonly Lazy<Encoding> s_fallbackEncoding = new(CreateFallbackEncoding); 33internal static Encoding CreateFallbackEncoding() 41?? Encoding.GetEncoding(name: "Latin1"); 50Encoding.RegisterProvider(provider); 57internal static Encoding? TryGetCodePageEncoding(int codePage) 63return Encoding.GetEncoding(codePage); 73/// from <see cref="SourceText.From(Stream, Encoding, SourceHashAlgorithm, bool)"/> in two ways: 92Encoding? defaultEncoding = null, 104Lazy<Encoding> getEncoding, 105Encoding? defaultEncoding = null, 148Encoding encoding, 249internal static SourceText Create(Stream stream, Lazy<Encoding> getEncoding, Encoding defaultEncoding, SourceHashAlgorithm checksumAlgorithm, bool canBeEmbedded) 252internal static SourceText Decode(Stream data, Encoding encoding, SourceHashAlgorithm checksumAlgorithm, bool throwIfBinaryDetected, bool canBeEmbedded)

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

12internal static bool TryGetMaxCharCount(this Encoding encoding, long length, out int maxCharCount)

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

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

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

14private static readonly Encoding s_utf8bom = new UTF8Encoding(encoderShouldEmitUTF8Identifier: true);

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\EmbeddedLanguages\VirtualChars\VirtualCharSequenceSourceText.cs (2)

19public override Encoding? Encoding { get; } 21public VirtualCharSequenceSourceText(ImmutableSegmentedList<VirtualChar> virtualChars, Encoding? encoding)

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

47_reader = new BinaryReader(stream, Encoding.UTF8, leaveOpen); 219public Encoding? ReadEncoding() 228return Encoding.GetEncoding(ReadRequiredString()); 234return Encoding.GetEncoding(ReadInt32());

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

94_writer = new BinaryWriter(stream, Encoding.UTF8, leaveOpen); 517public void WriteEncoding(Encoding? encoding)

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

276/// Encoding serialized as <see cref="Encoding.WebName"/>. 287/// Encoding serialized as <see cref="Encoding.CodePage"/>.

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

src\roslyn\src\Compilers\Core\Portable\EncodedStringText.cs (15)

23private static readonly Encoding s_utf8Encoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true); 25private static readonly Lazy<Encoding> s_fallbackEncoding = new(CreateFallbackEncoding); 33internal static Encoding CreateFallbackEncoding() 41?? Encoding.GetEncoding(name: "Latin1"); 50Encoding.RegisterProvider(provider); 57internal static Encoding? TryGetCodePageEncoding(int codePage) 63return Encoding.GetEncoding(codePage); 73/// from <see cref="SourceText.From(Stream, Encoding, SourceHashAlgorithm, bool)"/> in two ways: 92Encoding? defaultEncoding = null, 104Lazy<Encoding> getEncoding, 105Encoding? defaultEncoding = null, 148Encoding encoding, 249internal static SourceText Create(Stream stream, Lazy<Encoding> getEncoding, Encoding defaultEncoding, SourceHashAlgorithm checksumAlgorithm, bool canBeEmbedded) 252internal static SourceText Decode(Stream data, Encoding encoding, SourceHashAlgorithm checksumAlgorithm, bool throwIfBinaryDetected, bool canBeEmbedded)

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

12internal static bool TryGetMaxCharCount(this Encoding encoding, long length, out int maxCharCount)

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

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

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\VirtualCharSequenceSourceText.cs (2)

19public override Encoding? Encoding { get; } 21public VirtualCharSequenceSourceText(ImmutableSegmentedList<VirtualChar> virtualChars, Encoding? encoding)

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

47_reader = new BinaryReader(stream, Encoding.UTF8, leaveOpen); 219public Encoding? ReadEncoding() 228return Encoding.GetEncoding(ReadRequiredString()); 234return Encoding.GetEncoding(ReadInt32());

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

94_writer = new BinaryWriter(stream, Encoding.UTF8, leaveOpen); 517public void WriteEncoding(Encoding? encoding)

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

276/// Encoding serialized as <see cref="Encoding.WebName"/>. 287/// Encoding serialized as <see cref="Encoding.CodePage"/>.

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

CommandLine\CSharpCommandLineParser.cs (2)

111Encoding? codepage = null; 383var encoding = TryParseEncodingName(value);

Symbols\FileIdentifier.cs (1)

22private static readonly Encoding s_encoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);

Syntax\CSharpSyntaxTree.cs (8)

313public static SyntaxTree Create(CSharpSyntaxNode root, CSharpParseOptions? options = null, string? path = "", Encoding? encoding = null) 333Encoding? encoding, 360Encoding? encoding, 392/// <para>NOTE: Do not use this method elsewhere, instead use <see cref="Create(CSharpSyntaxNode, CSharpParseOptions, string, Encoding)"/> method for creating a syntax tree.</para> 433Encoding? encoding = null, 454Encoding? encoding, 917Encoding? encoding, 929Encoding? encoding,

Syntax\CSharpSyntaxTree.Dummy.cs (2)

44public override Encoding Encoding 46get { return Encoding.UTF8; }

Syntax\CSharpSyntaxTree.LazySyntaxTree.cs (1)

55public override Encoding? Encoding

Syntax\CSharpSyntaxTree.ParsedSyntaxTree.cs (3)

26private readonly Encoding? _encodingOpt; 33Encoding? encodingOpt, 78public override Encoding? Encoding

Syntax\SyntaxFactory.cs (6)

1576public static SyntaxTree SyntaxTree(SyntaxNode root, ParseOptions? options = null, string path = "", Encoding? encoding = null) 1583/// <inheritdoc cref="CSharpSyntaxTree.ParseText(string, CSharpParseOptions?, string, Encoding?, CancellationToken)"/> 1588Encoding? encoding = null, 1952return SourceText.From(text, Encoding.UTF8).GetSubText(offset); 2834Encoding? encoding, 2861Encoding? encoding,

EmbeddedLanguages\CSharpTestEmbeddedLanguageUtilities.cs (1)

22var encoding = semanticModel.SyntaxTree.Encoding;

SyncedSource\FileBasedPrograms\FileLevelDirectiveHelpers.cs (1)

237var encoding = Text.Encoding ?? new UTF8Encoding(encoderShouldEmitUTF8Identifier: false);

SyncedSource\FileBasedPrograms\Sha256Hasher.cs (1)

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

Workspace\LanguageServices\CSharpSyntaxTreeFactoryService.cs (1)

56public override SyntaxTree CreateSyntaxTree(string filePath, ParseOptions options, SourceText text, Encoding encoding, SourceHashAlgorithm checksumAlgorithm, SyntaxNode root)

Workspace\LanguageServices\CSharpSyntaxTreeFactoryService.ParsedSyntaxTree.cs (2)

22public override Encoding? Encoding { get; } 33Encoding? encoding,

Api\HotReloadMSBuildWorkspace.cs (1)

210private static async ValueTask<SourceText> GetSourceTextAsync(string filePath, Encoding encoding, SourceHashAlgorithm checksumAlgorithm, CancellationToken cancellationToken)

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

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

EditAndContinue\CommittedSolution.cs (5)

329var maybePdbHasDocument = TryReadSourceFileDebugInfo(document, sourceText.Encoding, out var requiredChecksum, out var checksumAlgorithm, out var defaultEncoding); 373Encoding? defaultEncoding, 446Encoding? defaultEncoding, 475private bool? TryReadSourceFileDebugInfo(Document document, Encoding? documentEncoding, out ImmutableArray<byte> checksum, out SourceHashAlgorithm checksumAlgorithm, out Encoding? defaultEncoding)

EditAndContinue\EditAndContinueDebugInfoReader.cs (6)

35public abstract Encoding? GetDefaultSourceFileEncoding(); 118public override Encoding? GetDefaultSourceFileEncoding() 125private readonly Lazy<Encoding?> _lazyDefaultSourceFileEncoding; 172public override Encoding? GetDefaultSourceFileEncoding() 175private Encoding? ReadDefaultSourceFileEncoding() 187return Encoding.GetEncoding(encodingName);

EditAndContinue\TraceLog.cs (1)

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

MetadataAsSource\MetadataAsSourceGeneratedFileInfo.cs (2)

21public static Encoding Encoding => Encoding.UTF8;

PdbSourceDocument\IPdbSourceDocumentLoaderService.cs (1)

15Task<SourceFileInfo?> LoadSourceDocumentAsync(string tempFilePath, SourceDocument sourceDocument, Encoding encoding, TelemetryMessage telemetry, bool useExtendedTimeout, ISourceLinkService? sourceLinkService, CancellationToken cancellationToken);

PdbSourceDocument\PdbSourceDocumentLoaderService.cs (5)

32public async Task<SourceFileInfo?> LoadSourceDocumentAsync(string tempFilePath, SourceDocument sourceDocument, Encoding encoding, TelemetryMessage telemetry, bool useExtendedTimeout, ISourceLinkService? sourceLinkService, CancellationToken cancellationToken) 41private SourceFileInfo? TryGetEmbeddedSourceFile(string tempFilePath, SourceDocument sourceDocument, Encoding encoding, TelemetryMessage telemetry) 119private async Task<SourceFileInfo?> TryGetSourceLinkFileAsync(SourceDocument sourceDocument, Encoding encoding, TelemetryMessage telemetry, bool useExtendedTimeout, ISourceLinkService? sourceLinkService, CancellationToken cancellationToken) 163private SourceFileInfo? TryGetOriginalFile(SourceDocument sourceDocument, Encoding encoding, TelemetryMessage telemetry) 185private static SourceFileInfo? LoadSourceFile(string filePath, SourceDocument sourceDocument, Encoding encoding, string sourceDescription, bool ignoreChecksum, bool fromRemoteLocation)

PdbSourceDocument\PdbSourceDocumentMetadataAsSourceFileProvider.cs (7)

202Encoding? defaultEncoding = null; 205defaultEncoding = Encoding.GetEncoding(encodingString); 209defaultEncoding = Encoding.GetEncoding(fallbackEncodingString); 250var encoding = defaultEncoding ?? Encoding.UTF8; 329SourceFileInfo?[] sourceFileInfos, Encoding encoding, ProjectId projectId, Workspace sourceWorkspace, Project sourceProject) 436internal record struct SourceDocumentInfo(DocumentId DocumentId, Encoding Encoding, SourceHashAlgorithm ChecksumAlgorithm, ProjectId SourceProjectId, Workspace SourceWorkspace, DocumentInfo DocumentInfo);

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

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

Copilot\SemanticSearch\CopilotSemanticSearchUtilities.cs (1)

30public static SyntaxTree CreateSyntaxTree(SolutionServices services, string language, string? filePath, ParseOptions options, SourceText? text, Encoding? encoding, SourceHashAlgorithm checksumAlgorithm, SyntaxNode root)

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

13private static readonly Encoding s_utf8bom = new UTF8Encoding(encoderShouldEmitUTF8Identifier: true);

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

75/// <param name="encoding">The <see cref="System.Text.Encoding"/> to use to read the <paramref name="stream"/>.</param> 77public static RazorSourceDocument ReadFrom(Stream stream, string fileName, Encoding encoding) 98/// <param name="encoding">The <see cref="System.Text.Encoding"/> to use to read the <paramref name="stream"/>.</param> 101public static RazorSourceDocument ReadFrom(Stream stream, Encoding encoding, RazorSourceDocumentProperties properties) 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); 203/// <param name="encoding">The <see cref="System.Text.Encoding"/> of the file <paramref name="content"/> was read from.</param> 205public static RazorSourceDocument Create(string content, string fileName, Encoding encoding) 229public static RazorSourceDocument Create(string content, Encoding encoding, RazorSourceDocumentProperties properties)

SourceGenerators\RazorSourceGenerator.RazorProviders.cs (1)

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

CompilationOptionsReader.cs (5)

112public Encoding GetEncoding() 121var encoding = encodingString is null 122? Encoding.UTF8 123: Encoding.GetEncoding(encodingString); 181var encoding = GetEncoding();

Records.cs (1)

23Encoding SourceTextEncoding);

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

23private static readonly Encoding s_utf8Encoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true); 25private static readonly Lazy<Encoding> s_fallbackEncoding = new(CreateFallbackEncoding); 33internal static Encoding CreateFallbackEncoding() 41?? Encoding.GetEncoding(name: "Latin1"); 50Encoding.RegisterProvider(provider); 57internal static Encoding? TryGetCodePageEncoding(int codePage) 63return Encoding.GetEncoding(codePage); 73/// from <see cref="SourceText.From(Stream, Encoding, SourceHashAlgorithm, bool)"/> in two ways: 92Encoding? defaultEncoding = null, 104Lazy<Encoding> getEncoding, 105Encoding? defaultEncoding = null, 148Encoding encoding, 249internal static SourceText Create(Stream stream, Lazy<Encoding> getEncoding, Encoding defaultEncoding, SourceHashAlgorithm checksumAlgorithm, bool canBeEmbedded) 252internal static SourceText Decode(Stream data, Encoding encoding, SourceHashAlgorithm checksumAlgorithm, bool throwIfBinaryDetected, bool canBeEmbedded)

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

12internal static bool TryGetMaxCharCount(this Encoding encoding, long length, out int maxCharCount)

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

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

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

14private static readonly Encoding s_utf8bom = new UTF8Encoding(encoderShouldEmitUTF8Identifier: true);

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\EmbeddedLanguages\VirtualChars\VirtualCharSequenceSourceText.cs (2)

19public override Encoding? Encoding { get; } 21public VirtualCharSequenceSourceText(ImmutableSegmentedList<VirtualChar> virtualChars, Encoding? encoding)

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

47_reader = new BinaryReader(stream, Encoding.UTF8, leaveOpen); 219public Encoding? ReadEncoding() 228return Encoding.GetEncoding(ReadRequiredString()); 234return Encoding.GetEncoding(ReadInt32());

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

94_writer = new BinaryWriter(stream, Encoding.UTF8, leaveOpen); 517public void WriteEncoding(Encoding? encoding)

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

276/// Encoding serialized as <see cref="Encoding.WebName"/>. 287/// Encoding serialized as <see cref="Encoding.CodePage"/>.

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

ScriptOptions.cs (3)

114public Encoding? FileEncoding { get; private set; } 152Encoding? fileEncoding, 363public ScriptOptions WithFileEncoding(Encoding encoding)

HelloWorldGenerator.cs (3)

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

CommandLine\VisualBasicCommandLineParser.vb (1)

127Dim codepage As Encoding = Nothing

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

35Optional encoding As Encoding = Nothing) As SyntaxTree 47encoding As Encoding, 75Optional encoding As Encoding = Nothing, 288Return SourceText.From(text, Encoding.UTF8).GetSubText(offset)

Syntax\VisualBasicSyntaxTree.DummySyntaxTree.vb (2)

37Public Overrides ReadOnly Property Encoding As Encoding 39Return Encoding.UTF8

Syntax\VisualBasicSyntaxTree.LazySyntaxTree.vb (1)

60Public Overrides ReadOnly Property Encoding As Encoding

Syntax\VisualBasicSyntaxTree.ParsedSyntaxTree.vb (3)

27Private ReadOnly _encodingOpt As Encoding 37encodingOpt As Encoding, 89Public Overrides ReadOnly Property Encoding As Encoding

Syntax\VisualBasicSyntaxTree.vb (6)

166Optional encoding As Encoding = Nothing, 186encoding As Encoding, 241Optional encoding As Encoding = Nothing, 251Optional encoding As Encoding = Nothing, 617encoding As Encoding, 638encoding As Encoding) As SyntaxTree

Workspace\LanguageServices\VisualBasicSyntaxTreeFactoryService.ParsedSyntaxTree.vb (2)

21Public Overrides ReadOnly Property Encoding As Encoding 32encoding As Encoding,

Workspace\LanguageServices\VisualBasicSyntaxTreeFactoryService.vb (1)

66Public Overrides Function CreateSyntaxTree(filePath As String, options As ParseOptions, text As SourceText, encoding As Encoding, checksumAlgorithm As SourceHashAlgorithm, root As SyntaxNode) As SyntaxTree

ExternalAccess\UnitTesting\Api\UnitTestingEncodedStringTextAccessor.cs (1)

13public static SourceText Create(Stream stream, Encoding defaultEncoding)

Log\AnalyzerNameForTelemetry.cs (1)

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

Serialization\SerializableSourceText.cs (2)

180var encoding = reader.ReadEncoding(); 189var encoding = reader.ReadEncoding();

Shared\Extensions\SourceTextExtensions.cs (1)

226public static SourceText ReadFrom(ITextFactoryService textService, ObjectReader reader, Encoding? encoding, SourceHashAlgorithm checksumAlgorithm, CancellationToken cancellationToken)

SourceGeneration\IRemoteSourceGenerationService.cs (1)

84/// <param name="EncodingName">Result of <see cref="SourceText.Encoding"/>'s <see cref="Encoding.WebName"/>.</param>

src\roslyn\src\Compilers\Core\Portable\EncodedStringText.cs (15)

23private static readonly Encoding s_utf8Encoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true); 25private static readonly Lazy<Encoding> s_fallbackEncoding = new(CreateFallbackEncoding); 33internal static Encoding CreateFallbackEncoding() 41?? Encoding.GetEncoding(name: "Latin1"); 50Encoding.RegisterProvider(provider); 57internal static Encoding? TryGetCodePageEncoding(int codePage) 63return Encoding.GetEncoding(codePage); 73/// from <see cref="SourceText.From(Stream, Encoding, SourceHashAlgorithm, bool)"/> in two ways: 92Encoding? defaultEncoding = null, 104Lazy<Encoding> getEncoding, 105Encoding? defaultEncoding = null, 148Encoding encoding, 249internal static SourceText Create(Stream stream, Lazy<Encoding> getEncoding, Encoding defaultEncoding, SourceHashAlgorithm checksumAlgorithm, bool canBeEmbedded) 252internal static SourceText Decode(Stream data, Encoding encoding, SourceHashAlgorithm checksumAlgorithm, bool throwIfBinaryDetected, bool canBeEmbedded)

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

12internal static bool TryGetMaxCharCount(this Encoding encoding, long length, out int maxCharCount)

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

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

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\VirtualCharSequenceSourceText.cs (2)

19public override Encoding? Encoding { get; } 21public VirtualCharSequenceSourceText(ImmutableSegmentedList<VirtualChar> virtualChars, Encoding? encoding)

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

47_reader = new BinaryReader(stream, Encoding.UTF8, leaveOpen); 219public Encoding? ReadEncoding() 228return Encoding.GetEncoding(ReadRequiredString()); 234return Encoding.GetEncoding(ReadInt32());

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

94_writer = new BinaryWriter(stream, Encoding.UTF8, leaveOpen); 517public void WriteEncoding(Encoding? encoding)

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

276/// Encoding serialized as <see cref="Encoding.WebName"/>. 287/// Encoding serialized as <see cref="Encoding.CodePage"/>.

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

TemporaryStorage\TemporaryStorageService.cs (5)

123var size = Encoding.Unicode.GetMaxByteCount(text.Length); 129using var writer = new StreamWriter(stream, Encoding.Unicode); 195Encoding? encoding, 268Encoding? encoding, 274public Encoding? Encoding => encoding;

Workspace\Host\SyntaxTreeFactory\AbstractSyntaxTreeFactoryService.cs (1)

27public abstract SyntaxTree CreateSyntaxTree(string filePath, ParseOptions options, SourceText text, Encoding encoding, SourceHashAlgorithm checksumAlgorithm, SyntaxNode root);

Workspace\Host\SyntaxTreeFactory\ISyntaxTreeFactoryService.cs (1)

30SyntaxTree CreateSyntaxTree(string? filePath, ParseOptions options, SourceText? text, Encoding? encoding, SourceHashAlgorithm checksumAlgorithm, SyntaxNode root);

Workspace\Host\TextFactory\ITextFactoryService.cs (2)

33SourceText CreateText(Stream stream, Encoding? defaultEncoding, SourceHashAlgorithm checksumAlgorithm, CancellationToken cancellationToken); 43SourceText CreateText(TextReader reader, Encoding? encoding, SourceHashAlgorithm checksumAlgorithm, CancellationToken cancellationToken);

Workspace\Host\TextFactory\TextFactoryService.cs (2)

25public SourceText CreateText(Stream stream, Encoding? defaultEncoding, SourceHashAlgorithm checksumAlgorithm, CancellationToken cancellationToken) 31public SourceText CreateText(TextReader reader, Encoding? encoding, SourceHashAlgorithm checksumAlgorithm, CancellationToken cancellationToken)

Workspace\Solution\DocumentState.cs (2)

497var encoding = newRoot.SyntaxTree.Encoding; 532Encoding? encoding,

Workspace\Solution\FileTextLoader.cs (2)

34public Encoding? DefaultEncoding { get; } 47public FileTextLoader(string path, Encoding? defaultEncoding)

Workspace\Solution\SolutionCompilationState.RegularCompilationTracker_Generators.cs (1)

234generatedSource, contentIdentity.EncodingName is null ? null : Encoding.GetEncoding(contentIdentity.EncodingName), contentIdentity.ChecksumAlgorithm);

Workspace\Solution\TextLoader.cs (1)

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

Workspace\WorkspaceFileTextLoader.cs (1)

22internal WorkspaceFileTextLoader(SolutionServices services, string path, Encoding? defaultEncoding)

MSBuild\MSBuildProjectLoader.Worker.cs (2)

211Encoding? encoding; 346private ImmutableArray<DocumentInfo> CreateDocumentInfos(IReadOnlyList<DocumentFileInfo> documentFileInfos, ProjectId projectId, Encoding? encoding)

MSBuild\MSBuildWorkspace.cs (5)

417var encoding = DetermineEncoding(text, document); 435var encoding = DetermineEncoding(text, document); 448private static Encoding? DetermineEncoding(SourceText text, TextDocument document) 510this.SaveDocumentText(info.Id, fullPath, text, text.Encoding ?? Encoding.UTF8); 514private void SaveDocumentText(DocumentId id, string fullPath, SourceText newText, Encoding encoding)

AbstractBuildHost.cs (1)

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

JsonSettings.cs (1)

15public static readonly Encoding StreamEncoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false);

DataFrame.IO.cs (10)

110bool addIndexColumn = false, Encoding encoding = null, 490private readonly Encoding _encoding; 493public WrappedStreamReaderOrStringReader(Stream stream, Encoding encoding) 571Encoding encoding = null, bool renameDuplicatedColumns = false, CultureInfo cultureInfo = null, 584WrappedStreamReaderOrStringReader wrappedStreamReaderOrStringReader = new WrappedStreamReaderOrStringReader(csvStream, encoding ?? Encoding.UTF8); 600Encoding encoding = null, CultureInfo cultureInfo = null) 616Encoding encoding = null, CultureInfo cultureInfo = null) 638Encoding encoding = null, CultureInfo cultureInfo = null) 654Encoding encoding = null, CultureInfo cultureInfo = null) 668encoding = Encoding.ASCII;

DataFrameColumns\ArrowStringDataFrameColumn.cs (6)

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;

TextFieldParser.cs (9)

355InitializeFromPath(path, Encoding.ASCII, detectEncoding: true); 358public TextFieldParser(string path, Encoding defaultEncoding) 363public TextFieldParser(string path, Encoding defaultEncoding, bool detectEncoding) 370InitializeFromStream(stream, Encoding.ASCII, detectEncoding: true); 373public TextFieldParser(Stream stream, Encoding defaultEncoding) 378public TextFieldParser(Stream stream, Encoding defaultEncoding, bool detectEncoding) 383public TextFieldParser(Stream stream, Encoding defaultEncoding, bool detectEncoding, bool leaveOpen) 549private void InitializeFromPath(string path, Encoding defaultEncoding, bool detectEncoding) 565private void InitializeFromStream(Stream stream, Encoding defaultEncoding, bool detectEncoding)

ArrowStringColumnTests.cs (1)

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

DataFrame.IOTests.cs (1)

126return new MemoryStream(Encoding.Default.GetBytes(streamData));

src\Microsoft.Data.Analysis\TextFieldParser.cs (9)

355InitializeFromPath(path, Encoding.ASCII, detectEncoding: true); 358public TextFieldParser(string path, Encoding defaultEncoding) 363public TextFieldParser(string path, Encoding defaultEncoding, bool detectEncoding) 370InitializeFromStream(stream, Encoding.ASCII, detectEncoding: true); 373public TextFieldParser(Stream stream, Encoding defaultEncoding) 378public TextFieldParser(Stream stream, Encoding defaultEncoding, bool detectEncoding) 383public TextFieldParser(Stream stream, Encoding defaultEncoding, bool detectEncoding, bool leaveOpen) 549private void InitializeFromPath(string path, Encoding defaultEncoding, bool detectEncoding) 565private void InitializeFromStream(Stream stream, Encoding defaultEncoding, bool detectEncoding)

TextFieldParserTests.cs (2)

22return new MemoryStream(Encoding.Default.GetBytes(streamData)); 42using (var parser = new TextFieldParser(stream, defaultEncoding: Encoding.Unicode, detectEncoding: true, leaveOpen: true))

ContractDescriptorTarget.cs (2)

743? Encoding.Unicode.GetString(span) 744: Encoding.BigEndianUnicode.GetString(span);

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

BinaryWriterExtensions.cs (1)

22@this.Write(Encoding.Unicode.GetBytes(value + '\0'));

DiagnosticsIpc\IpcAdvertise.cs (1)

29private static byte[] Magic_V1 => Encoding.ASCII.GetBytes("ADVR_V1" + '\0');

DiagnosticsIpc\IpcHeader.cs (1)

35public static byte[] DotnetIpcV1 => Encoding.ASCII.GetBytes("DOTNET_IPC_V1" + '\0');

DiagnosticsIpc\IpcMessage.cs (1)

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

DiagnosticsIpc\IpcTransport.cs (1)

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

IpcHelpers.cs (1)

20string value = Encoding.Unicode.GetString(buffer, index, size).Substring(0, length - 1);

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

39string name = Encoding.ASCII.GetString(fileName).TrimEnd(' '); 43ulong timestamp = ulong.Parse(Encoding.ASCII.GetString(timestampBytes).TrimEnd(' ')); 48ulong ownerID = ulong.Parse(Encoding.ASCII.GetString(ownerIDBytes).TrimEnd(' ')); 53ulong groupID = ulong.Parse(Encoding.ASCII.GetString(groupIDBytes).TrimEnd(' ')); 58uint mode = Convert.ToUInt32(Encoding.ASCII.GetString(modeBytes).TrimEnd(' '), 8); 63ulong size = ulong.Parse(Encoding.ASCII.GetString(sizeBytes).TrimEnd(' '));

src\ArWriter.cs (7)

27Write(Encoding.ASCII.GetBytes(entry.Name.PadRight(16, ' ').Substring(0, 16))); 28Write(Encoding.ASCII.GetBytes(entry.Timestamp.ToString().PadRight(12, ' ').Substring(0, 12))); 29Write(Encoding.ASCII.GetBytes(entry.OwnerID.ToString().PadRight(6, ' ').Substring(0, 6))); 30Write(Encoding.ASCII.GetBytes(entry.GroupID.ToString().PadRight(6, ' ').Substring(0, 6))); 31Write(Encoding.ASCII.GetBytes(Convert.ToString(entry.Mode, 8).PadRight(8, ' ').Substring(0, 8))); 35Write(Encoding.ASCII.GetBytes(length.ToString().PadRight(10, ' ').Substring(0, 10))); 36Write(Encoding.ASCII.GetBytes("`\n"));

src\CpioReader.cs (14)

src\CpioWriter.cs (1)

23using StreamWriter writer = new(stream, Encoding.ASCII, bufferSize: -1, leaveOpen: true);

src\CreateChangelogFile.cs (1)

41using StreamWriter writer = new(stream, Encoding.ASCII);

src\CreateControlFile.cs (1)

46using StreamWriter writer = new(stream, Encoding.ASCII);

src\CreateDebPackage.cs (1)

35arWriter.AddEntry(new ArEntry("debian-binary", timestamp, 0, 0, Permissions, new MemoryStream(Encoding.ASCII.GetBytes("2.0\n"))));

src\CreateMD5SumsFile.cs (1)

33using StreamWriter writer = new(outputFile, Encoding.ASCII);

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

24byte[] bytes = Encoding.UTF8.GetBytes(value); 66internal static void StringReplace(string fileName, Dictionary<string, string> tokenReplacements, Encoding encoding) 83StringReplace(fileName, tokenReplacements, Encoding.UTF8); 143byte[] nameBytes = Encoding.Unicode.GetBytes(name);

BuiltInCommand.cs (1)

183public ICommand StandardOutputEncoding(Encoding encoding)

Command.cs (1)

107public ICommand StandardOutputEncoding(Encoding encoding)

ICommand.cs (1)

28ICommand StandardOutputEncoding(Encoding encoding);

UILanguageOverride.cs (2)

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

237var encoding = Text.Encoding ?? new UTF8Encoding(encoderShouldEmitUTF8Identifier: false);

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

Model\Document.cs (3)

17private static readonly Encoding s_utf8WithBom = new UTF8Encoding(encoderShouldEmitUTF8Identifier: true); 18private static readonly Encoding s_utf8WithoutBom = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false); 24public Encoding Encoding { get; set; } = s_utf8WithBom;

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

124Assert.Equal(expectedData, Encoding.UTF8.GetString(content.Data.ToArray())); 300Assert.Equal("hello world", Encoding.ASCII.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)

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,

Linux\OSFileSystem.cs (5)

41return Encoding.ASCII.GetChars(rentedBuffer.Span.Slice(0, read), destination); 75_ = Encoding.ASCII.GetChars(buffer.Span.Slice(start, length), destination.GetSpan(length)); 90_ = Encoding.ASCII.GetChars(buffer.Span.Slice(start, length), destination.GetSpan(length)); 131_ = Encoding.ASCII.GetChars(buffer.Slice(0, end), destination.GetSpan(end)); 138_ = Encoding.ASCII.GetChars(buffer.Slice(0, end), destination.GetSpan(end));

Linux\OSFileSystemTests.cs (3)

98var fileBytes = Encoding.ASCII.GetBytes(fileContent); 149var fileBytes = Encoding.ASCII.GetBytes(fileContent); 198var fileBytes = Encoding.ASCII.GetBytes(fileContent.ToString());

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

Rfc6238AuthenticationService.cs (1)

18private static readonly Encoding _encoding = new UTF8Encoding(false, true);

UserManager.cs (1)

2814return Encoding.Unicode.GetBytes(await GetSecurityStampAsync(user).ConfigureAwait(false));

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

100!Encoding.ASCII.TryGetBytes(name, destination.Slice(1), out int length) ||

Resolver\EncodedDomainName.cs (1)

29sb.Append(Encoding.ASCII.GetString(label.Span));

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

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

16 public override Encoding Encoding => _writer.Encoding;

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

788private static Encoding _utf8NoBom; 794public static StreamWriter OpenWriter(Stream stream, Encoding encoding = null, int bufferSize = 1024, bool leaveOpen = true)

Utilities\TextReaderStream.cs (4)

22private readonly Encoding _encoding; 58/// Create a stream wrapping the given text reader, using the <see cref="Encoding.UTF8"/> 63: this(baseReader, Encoding.UTF8) 76public TextReaderStream(TextReader baseReader, Encoding encoding)

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

27private readonly Encoding _encoding; 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))

Utils\ToByteArrayExtensions.cs (4)

224return checked(sizeof(int) + Encoding.Unicode.GetByteCount(a)); 229byte[] bytes = Encoding.Unicode.GetBytes(a); 237byte[] bytes = Encoding.Unicode.GetBytes(a); 248string a = Encoding.Unicode.GetString(buffer, position, length);

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

Helpers\EmptyWriter.cs (1)

16public override Encoding Encoding => null;

Dynamic\TensorFlow\ImageClassification.cs (1)

144TarArchive tarArchive = TarArchive.CreateInputTarArchive(gzipStream, Encoding.ASCII);

docs\samples\Microsoft.ML.Samples\Dynamic\TensorFlow\ImageClassification.cs (1)

144TarArchive tarArchive = TarArchive.CreateInputTarArchive(gzipStream, Encoding.ASCII);

BaseTestBaseline.cs (1)

998protected static StreamWriter OpenWriter(string path, bool append = false, Encoding encoding = null, int bufferSize = 1024)

BytesStreamSource.cs (1)

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

TestLogger.cs (2)

14private Encoding _encoding; 17public override Encoding Encoding => _encoding;

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)

AuthHandshakeMessageHandler.cs (2)

196var authValue = new AuthenticationHeaderValue(BasicAuthScheme, Convert.ToBase64String(Encoding.ASCII.GetBytes($"{privateRepoCreds.Username}:{privateRepoCreds.Password}"))); 515var header = new AuthenticationHeaderValue(BasicAuthScheme, Convert.ToBase64String(Encoding.ASCII.GetBytes($"{privateRepoCreds.Username}:{privateRepoCreds.Password}")));

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

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

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)); 598var encoding = Encoding.GetEncoding(parts[1].ToString()); 716var encoding = Encoding.GetEncoding(parts[0].ToString());

MediaTypeHeaderValue.cs (3)

108/// the <see cref="Charset"/> to <see cref="Encoding.WebName"/>. 110public Encoding? Encoding 121return Encoding.GetEncoding(charset.Value);

src\aspnetcore\src\Shared\HttpRuleParser.cs (2)

51internal static readonly Encoding DefaultHttpEncoding = Encoding.GetEncoding("iso-8859-1");

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

MsDeploy\CommonUtility.cs (1)

441public static void SaveDocument(XmlDocument document, string outputFileName, Encoding encode)

Tasks\Http\HttpClientExtensions.cs (4)

44Encoding encoding, 100Encoding encoding, 274var reader = new StreamReader(stream, Encoding.UTF8); 286byte[] plainAuthBytes = Encoding.ASCII.GetBytes(plainAuth);

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

49plainPWD = Encoding.Unicode.GetString(uncrypted);

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

src\sdk\src\RazorSdk\Tool\ServerProtocol\ServerRequest.cs (2)

148using (var reader = new BinaryReader(new MemoryStream(requestBuffer), Encoding.Unicode)) 171using (var writer = new BinaryWriter(memoryStream, Encoding.Unicode))

src\sdk\src\RazorSdk\Tool\ServerProtocol\ServerResponse.cs (2)

49using (var writer = new BinaryWriter(memoryStream, Encoding.Unicode)) 107using (var reader = new BinaryReader(new MemoryStream(responseBuffer), Encoding.Unicode))

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

_generated\189\Windows.Win32.PCSTR.g.cs (1)

69 public override string ToString() => this.Value is null ? null : new string((sbyte*)this.Value, 0, this.Length, global::System.Text.Encoding.Default);

_generated\201\Windows.Win32.PInvokeCore.KERNEL32.dll.g.cs (3)

189 fixed (byte* lpMultiByteStrLocal = lpMultiByteStr is object ? global::System.Text.Encoding.Default.GetBytes(lpMultiByteStr) : null) 231 fixed (byte* lpDefaultCharLocal = lpDefaultChar is object ? global::System.Text.Encoding.Default.GetBytes(lpDefaultChar) : null) 246 fixed (byte* lpDefaultCharLocal = lpDefaultChar is object ? global::System.Text.Encoding.Default.GetBytes(lpDefaultChar) : null)

src\winforms\src\Microsoft.Private.Windows.Polyfills\System\Text\EncodingExtensions.cs (1)

8extension(Encoding encoding)

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

118DataFormatNames.Rtf => ReadRegisteredFormatStringFromHGLOBAL(hglobal, Encoding.Default), 241private static unsafe string ReadRegisteredFormatStringFromHGLOBAL(HGLOBAL hglobal, Encoding encoding) 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\Cpp2\Cpp2StyleEvaluatorDefinition.cs (1)

14private static readonly ConcurrentDictionary<Encoding, ITokenTrie> TokenCache = new();

Expressions\MSBuild\MSBuildStyleEvaluatorDefinition.cs (1)

14private static readonly ConcurrentDictionary<Encoding, ITokenTrie> TokenCache = new();

Expressions\Shared\SharedEvaluatorDefinition.cs (2)

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

Expressions\VisualBasic\VisualBasicStyleEvaluatorDefintion.cs (1)

14private static readonly ConcurrentDictionary<Encoding, ITokenTrie> TokenCache = new();

Operations\BalancedNesting.cs (1)

40public IOperation GetOperation(Encoding encoding, IProcessorState processorState)

Operations\Conditional.cs (2)

72public IOperation GetOperation(Encoding encoding, IProcessorState processorState) 114private void AddTokensOfTypeToTokenListAndTrie(ITokenTrie trie, List<IToken> tokenMasterList, IReadOnlyList<ITokenConfig> tokensOfType, int typeRemainder, Encoding encoding)

Operations\ExpandVariables.cs (1)

23public IOperation GetOperation(Encoding encoding, IProcessorState processor)

Operations\Include.cs (3)

33public IOperation GetOperation(Encoding encoding, IProcessorState processorState) 130Encoding realEncoding = EncodingUtil.Detect(composite, totalBytesRead, out byte[] bom); 134composite = Encoding.Convert(realEncoding, processor.Encoding, composite, bom.Length, totalBytesRead - bom.Length);

Operations\InlineMarkupConditional.cs (1)

37public IOperation GetOperation(Encoding encoding, IProcessorState processorState)

Operations\PhasedOperation.cs (1)

23public IOperation GetOperation(Encoding encoding, IProcessorState processorState)

Operations\Region.cs (1)

35public IOperation GetOperation(Encoding encoding, IProcessorState processorState)

Operations\Replacement.cs (1)

27public IOperation GetOperation(Encoding encoding, IProcessorState processorState)

Operations\SetFlag.cs (1)

41public IOperation GetOperation(Encoding encoding, IProcessorState processorState)

TokenConfig.cs (1)

45public IToken ToToken(Encoding encoding)

TokenConfigExtensions.cs (1)

26public static IToken Token(this string s, Encoding e)

Util\EncodingConfig.cs (3)

14public EncodingConfig(IEngineConfig config, Encoding encoding) 41public Encoding Encoding { get; } 57private void ExpandVariables(IEngineConfig config, Encoding encoding)

Util\EncodingUtil.cs (8)

14public static Encoding Detect(byte[] buffer, int currentBufferLength, out byte[] bom) 20return Encoding.UTF8; 29return Encoding.GetEncoding(12001); 36return Encoding.UTF32; 46return Encoding.UTF8; 56return Encoding.BigEndianUnicode; 63return Encoding.Unicode; 69return Encoding.UTF8;

Util\ProcessorState.cs (4)

13private static readonly ConcurrentDictionary<IReadOnlyList<IOperationProvider>, ConcurrentDictionary<Encoding, Trie<OperationTerminal>>> TrieLookup = new(); 66Encoding encoding = EncodingUtil.Detect(CurrentBuffer, CurrentBufferLength, out byte[] bom); 74ConcurrentDictionary<Encoding, Trie<OperationTerminal>> byEncoding = TrieLookup.GetOrAdd(operationProviders, x => new()); 140public Encoding Encoding => EncodingConfig.Encoding;

IEncodingConfig.cs (1)

10Encoding Encoding { get; }

IOperationProvider.cs (1)

12IOperation GetOperation(Encoding encoding, IProcessorState processorState);

IProcessorState.cs (1)

34Encoding Encoding { get; }

ITokenConfig.cs (1)

16IToken ToToken(Encoding encoding);

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

TestIdProvider.cs (1)

42var bytes = Encoding.Unicode.GetBytes(str);

Tasks\VSTestTask2.cs (4)

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

common\Tracing\RollingFileTraceListener.cs (5)

104private static Encoding GetEncodingWithFallback() 106Encoding encoding = (Encoding)new UTF8Encoding(false).Clone(); 361/// The <see cref="Encoding"/> to use. 363public TallyKeepingFileStreamWriter(FileStream stream, Encoding encoding)

Microsoft\VisualBasic\CompilerServices\Utils.vb (2)

72Friend Shared Function GetFileIOEncoding() As Encoding 73Return System.Text.Encoding.Default

Microsoft\VisualBasic\CompilerServices\VB6File.vb (1)

347Protected m_Encoding As Encoding

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

300Return OpenTextFileReader(file, Encoding.UTF8) 309Public Shared Function OpenTextFileReader(ByVal file As String, ByVal encoding As Encoding) As IO.StreamReader 322Return OpenTextFileWriter(file, append, Encoding.UTF8) 333ByVal encoding As Encoding) As IO.StreamWriter 367Public Shared Function ReadAllText(ByVal file As String, ByVal encoding As Encoding) As String 773WriteAllText(file, text, append, Encoding.UTF8) 786ByVal encoding As Encoding) 2156Friend Sub New(ByVal Encoding As Text.Encoding, ByVal Text As String, ByVal IgnoreCase As Boolean)

Microsoft\VisualBasic\Strings.vb (5)

157Private Function GetAscChrEncoding() As Encoding 158Return Encoding.GetEncoding(GetLocaleCodePage()) 175Dim enc As Encoding 246Dim enc As Encoding 1990If Encoding.GetEncoding(codepage) IsNot Nothing Then

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

50Private _encoding As Encoding = Encoding.UTF8 359Public Property Encoding() As Encoding 368Set(value As Encoding) 611Private Function GetFileEncoding(fileName As String) As Encoding 706Dim fileEncoding As Encoding = Encoding

Microsoft\VisualBasic\MyServices\FileSystemProxy.vb (4)

1284Public Function OpenTextFileReader(file As String, encoding As Encoding) As IO.StreamReader 1326encoding As Encoding) As IO.StreamWriter 1397Public Function ReadAllText(file As String, encoding As Encoding) As String 1521encoding As Encoding)

TestProperty\CustomKeyValueConverter.cs (1)

45using var stream = new MemoryStream(Encoding.Unicode.GetBytes(data));

TestProperty\CustomStringArrayConverter.cs (1)

38using var stream = new MemoryStream(Encoding.Unicode.GetBytes(data));

Utilities\EqtHash.cs (1)

32byte[] hash = provider.ComputeHash(System.Text.Encoding.Unicode.GetBytes(data));

XmlAttributePreservingWriter.cs (3)

19public XmlAttributePreservingWriter(string fileName, Encoding encoding) 23public XmlAttributePreservingWriter(Stream w, Encoding encoding) 298public override Encoding Encoding {

XmlFileInfoDocument.cs (9)

15private Encoding _textEncoding = null; 89private Encoding GetEncodingFromStream(Stream stream) { 90Encoding encoding = null; 111encoding = Encoding.UTF8; 113encoding = Encoding.BigEndianUnicode; 115encoding = Encoding.Unicode; 119encoding = Encoding.UTF7; 199private Encoding TextEncoding { 211return System.Text.Encoding.GetEncoding(value);

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

2463 return Encoding.Unicode.GetString (blob, index, count); 3001 value = Encoding.Unicode.GetString (bytes, 0, bytes.Length); 3055 return ReadStringBlob (signature, Encoding.UTF8); 3060 return ReadStringBlob (signature, Encoding.Unicode); 3063 string ReadStringBlob (uint signature, Encoding encoding) 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 (5)

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

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

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

Mono.Cecil.Pdb\NativePdbWriter.cs (1)

335 Write (CustomMetadataType.ForwardIterator, () => writer.WriteBytes(Encoding.Unicode.GetBytes(type.Name)));

AutomaticEncodingRestorer.cs (2)

19private Encoding? _originalOutputEncoding = null; 20private Encoding? _originalInputEncoding = null;

XMake.cs (3)

2310Console.OutputEncoding = Encoding.UTF8; 2312Console.InputEncoding = Encoding.UTF8; 2350Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);

CoordinatorServer.Connection.cs (2)

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

src\runtime\src\libraries\shims\mscorlib\ref\mscorlib.cs (1)

1106[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Text.Encoding))]

netstandard.cs (1)

2041[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Text.Encoding))]

StaticGraphRestoreTaskBase.cs (2)

113Encoding utf8Encoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true); 155Encoding previousConsoleInputEncoding = Console.InputEncoding;

GetPackOutputItemsTask.cs (1)

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

ConcurrencyUtilities.cs (1)

283var hash = sha.ComputeHash(Encoding.UTF32.GetBytes(normalizedPath));

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

19return StreamFromString(content, Encoding.UTF8); 22public static Stream StreamFromString(string content, Encoding encoding)

PackageCreation\Authoring\PackageBuilder.cs (1)

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

Signing\Archive\SignedPackageArchiveIOUtility.cs (2)

612var fileNameBytes = Encoding.ASCII.GetBytes(_signingSpecification.SignaturePath); 689var fileNameBytes = Encoding.ASCII.GetBytes(_signingSpecification.SignaturePath);

Signing\Archive\SignedPackageArchiveUtility.cs (1)

145var expectedFileName = Encoding.ASCII.GetBytes(_signingSpecification.SignaturePath);

Signing\Cms\HeapBlockRetainer.cs (1)

31var b = Encoding.ASCII.GetBytes(s);

Signing\Content\KeyPairFileReader.cs (1)

19public KeyPairFileReader(Stream stream, Encoding encoding)

Signing\Content\KeyPairFileWriter.cs (1)

15public KeyPairFileWriter(Stream stream, Encoding encoding, bool leaveOpen)

Signing\DerEncoding\DerEncoder.cs (1)

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

Signing\DerEncoding\DerSequenceReader.cs (6)

339string str = System.Text.Encoding.UTF8.GetString(_data, _position, contentLength); 375string str = System.Text.Encoding.ASCII.GetString(_data, _position, contentLength); 388string ia5String = System.Text.Encoding.ASCII.GetString(_data, _position, contentLength); 419var decodedTime = Encoding.ASCII.GetString(_data, _position, contentLength); 434string str = System.Text.Encoding.BigEndianUnicode.GetString(_data, _position, contentLength); 480string decodedTime = System.Text.Encoding.ASCII.GetString(_data, _position, contentLength);

Signing\Specifications\SigningSpecifications.cs (1)

57public abstract Encoding Encoding { get; }

Signing\Specifications\SigningSpecificationsV1.cs (2)

14private static readonly Encoding _encoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false); 63public override Encoding Encoding => _encoding;

Signing\Utility\CertificateUtility.cs (2)

515urls.Add(Encoding.ASCII.GetString(uriBytes)); 570urls.Add(Encoding.ASCII.GetString(uriBytes));

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)

src\wpf\src\Microsoft.DotNet.Wpf\src\PresentationFramework\System\Windows\Markup\BamlBinaryWriter.cs (1)

21public BamlBinaryWriter(Stream stream, Encoding code)

src\wpf\src\Microsoft.DotNet.Wpf\src\WindowsBase\System\IO\Packaging\CompoundFile\FormatVersion.cs (1)

303binarywriter = new BinaryWriter(stream, System.Text.Encoding.Unicode);

MS\Internal\Ink\InkSerializedFormat\CustomAttributeSerializer.cs (2)

287bw.Write( System.Text.Encoding.Unicode.GetBytes( data ) ); 682return System.Text.Encoding.Unicode.GetString(bytestring);

System\Windows\Media\ImageSourceConverter.cs (2)

244string strPBrush = System.Text.Encoding.ASCII.GetString(rawData, pHeader.headersize + 12, 6); 252byte[] searchArray = System.Text.Encoding.ASCII.GetBytes("BM");

src\wpf\src\Microsoft.DotNet.Wpf\src\Shared\MS\Internal\Text\InternalEncoding.cs (6)

17Encoding.RegisterProvider(CodePagesEncodingProvider.Instance); 20internal static Encoding GetEncoding(int codepage) 22return Encoding.GetEncoding(codepage); 25internal static byte[] Convert(System.Text.Encoding srcEncoding, System.Text.Encoding dstEncoding, byte[] bytes) 27return Encoding.Convert(srcEncoding, dstEncoding, bytes);

System\Windows\Controls\DataGridClipboardHelper.cs (3)

79byte[] sourceBytes = Encoding.Unicode.GetBytes(content.ToString()); 80byte[] destinationBytes = InternalEncoding.Convert(Encoding.Unicode, Encoding.UTF8, sourceBytes);

System\Windows\Documents\FixedSchema.cs (2)

42if (!encoding.Equals(Encoding.Unicode.WebName, StringComparison.OrdinalIgnoreCase) && 43!encoding.Equals(Encoding.UTF8.WebName, StringComparison.OrdinalIgnoreCase))

System\Windows\Documents\RtfToXamlLexer.cs (2)

307internal Encoding CurrentEncoding 594private Encoding _currentEncoding;

System\Windows\Documents\RtfToXamlReader.cs (3)

3392Encoding e = InternalEncoding.GetEncoding(CodePageList[i]); 7748_rtfBytes = Encoding.Default.GetBytes(rtfString); 8769Encoding ec = InternalEncoding.GetEncoding(932);

System\Windows\Documents\WinRTSpellerInterop.cs (1)

628using (StreamWriter writer = new StreamWriter(targetStream, Text.Encoding.Unicode))

System\Windows\Documents\XamlToRtfWriter.cs (3)

3896Encoding e = null; 3928private static void AppendRtfChar(StringBuilder sb, char c, int cp, ref Encoding e, byte[] rgAnsi, char[] rgChar) 4011private static void AppendRtfUnicodeChar(StringBuilder sb, char c, int cp, ref Encoding e, byte[] rgAnsi, char[] rgChar)

System\Windows\Markup\BamlBinaryReader.cs (1)

18public BamlBinaryReader(Stream stream, Encoding code)

System\Windows\Markup\BamlBinaryWriter.cs (1)

21public BamlBinaryWriter(Stream stream, Encoding code)

MS\Internal\Documents\RightsManagementManager.cs (1)

1436template = File.ReadAllText(templateLocalPath, Encoding.Unicode);

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\aspnetcore\src\Shared\CertificateGeneration\CertificateManager.cs (5)

690pemEnvelope = Encoding.ASCII.GetBytes(pem); 706pemEnvelope = Encoding.ASCII.GetBytes(pem); 712bytes = Encoding.ASCII.GetBytes(PemEncoding.Write("CERTIFICATE", certificate.Export(X509ContentType.Cert))); 722bytes = Encoding.ASCII.GetBytes(PemEncoding.Write("CERTIFICATE", certificate.Export(X509ContentType.Cert))); 839bytePayload = Encoding.ASCII.GetBytes(AspNetHttpsOidFriendlyName);

src\aspnetcore\src\Shared\CertificateGeneration\UnixCertificateManager.cs (1)

687var encodedCommand = Convert.ToBase64String(System.Text.Encoding.Unicode.GetBytes(powershellScript));

Uuid.cs (1)

35byte[] nameBytes = Encoding.Unicode.GetBytes(name);

src\roslyn\src\Compilers\Core\Portable\EncodedStringText.cs (15)

23private static readonly Encoding s_utf8Encoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true); 25private static readonly Lazy<Encoding> s_fallbackEncoding = new(CreateFallbackEncoding); 33internal static Encoding CreateFallbackEncoding() 41?? Encoding.GetEncoding(name: "Latin1"); 50Encoding.RegisterProvider(provider); 57internal static Encoding? TryGetCodePageEncoding(int codePage) 63return Encoding.GetEncoding(codePage); 73/// from <see cref="SourceText.From(Stream, Encoding, SourceHashAlgorithm, bool)"/> in two ways: 92Encoding? defaultEncoding = null, 104Lazy<Encoding> getEncoding, 105Encoding? defaultEncoding = null, 148Encoding encoding, 249internal static SourceText Create(Stream stream, Lazy<Encoding> getEncoding, Encoding defaultEncoding, SourceHashAlgorithm checksumAlgorithm, bool canBeEmbedded) 252internal static SourceText Decode(Stream data, Encoding encoding, SourceHashAlgorithm checksumAlgorithm, bool throwIfBinaryDetected, bool canBeEmbedded)

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

12internal static bool TryGetMaxCharCount(this Encoding encoding, long length, out int maxCharCount)

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

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

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

14private static readonly Encoding s_utf8bom = new UTF8Encoding(encoderShouldEmitUTF8Identifier: true);

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\EmbeddedLanguages\VirtualChars\VirtualCharSequenceSourceText.cs (2)

19public override Encoding? Encoding { get; } 21public VirtualCharSequenceSourceText(ImmutableSegmentedList<VirtualChar> virtualChars, Encoding? encoding)

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

47_reader = new BinaryReader(stream, Encoding.UTF8, leaveOpen); 219public Encoding? ReadEncoding() 228return Encoding.GetEncoding(ReadRequiredString()); 234return Encoding.GetEncoding(ReadInt32());

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

94_writer = new BinaryWriter(stream, Encoding.UTF8, leaveOpen); 517public void WriteEncoding(Encoding? encoding)

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

276/// Encoding serialized as <see cref="Encoding.WebName"/>. 287/// Encoding serialized as <see cref="Encoding.CodePage"/>.

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

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

ServerProtocol\ServerRequest.cs (2)

148using (var reader = new BinaryReader(new MemoryStream(requestBuffer), Encoding.Unicode)) 171using (var writer = new BinaryWriter(memoryStream, Encoding.Unicode))

ServerProtocol\ServerResponse.cs (2)

49using (var writer = new BinaryWriter(memoryStream, Encoding.Unicode)) 107using (var reader = new BinaryReader(new MemoryStream(responseBuffer), Encoding.Unicode))

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.

ConsoleStresser.cs (1)

12var con = new StreamWriter(stdout, Encoding.ASCII);

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

3701StreamEncoding = Encoding.UTF8; 3710internal Encoding StreamEncoding { get; set; }

System\Configuration\DpapiProtectedConfigurationProvider.cs (2)

88return Encoding.Unicode.GetString(decryptedData); 120return (s != null) ? Encoding.Unicode.GetBytes(s) : Array.Empty<byte>();

System\Configuration\ImplicitMachineConfigHost.cs (1)

68stream = new MemoryStream(Encoding.UTF8.GetBytes(ImplicitMachineConfig));

System\Configuration\MgmtConfigurationRecord.cs (2)

601XmlParserContext context = new XmlParserContext(null, null, null, XmlSpace.Default, Encoding.Unicode); 1013Encoding encoding = null;

System\Configuration\XmlUtil.cs (1)

974XmlParserContext context = new XmlParserContext(null, null, null, XmlSpace.Default, Encoding.Unicode);

src\runtime\src\libraries\Common\src\System\Text\ConsoleEncoding.cs (4)

9public static Encoding RemovePreamble(this Encoding encoding) 26private readonly Encoding _encoding; 28internal ConsoleEncoding(Encoding encoding)

src\runtime\src\libraries\Common\src\System\Text\EncodingHelper.Unix.cs (2)

10internal static Encoding? GetEncodingFromCharset() 15try { return Encoding.GetEncoding(charset); }

System\Console.cs (8)

31private static Encoding? s_inputEncoding; 32private static Encoding? s_outputEncoding; 71public static Encoding InputEncoding 75Encoding? encoding = Volatile.Read(ref s_inputEncoding); 98Volatile.Write(ref s_inputEncoding, (Encoding)value.Clone()); 108public static Encoding OutputEncoding 112Encoding? encoding = Volatile.Read(ref s_outputEncoding); 152Volatile.Write(ref s_outputEncoding, (Encoding)value.Clone());

System\ConsolePal.Unix.cs (10)

70public static Encoding InputEncoding 75public static Encoding OutputEncoding 703private static Encoding GetConsoleEncoding() 705Encoding? enc = EncodingHelper.GetEncodingFromCharset(); 708Encoding.Default; 732public static void SetConsoleInputEncoding(Encoding enc) 738public static void SetConsoleOutputEncoding(Encoding enc) 1133data = stackalloc byte[Encoding.UTF8.GetMaxByteCount(value.Length)]; 1134int bytesToWrite = Encoding.UTF8.GetBytes(value, data); 1139data = Encoding.UTF8.GetBytes(value);

System\IO\CachedConsoleStream.cs (2)

14private readonly Encoding _encoding; 17public CachedConsoleStream(Encoding encoding) : base(FileAccess.Write)

System\IO\StdInReader.cs (2)

26private readonly Encoding _encoding; 35internal StdInReader(Encoding encoding)

System\TermInfo.cs (1)

381return Encoding.ASCII.GetString(bytes, 0, neededLength);

System\TermInfo.Database.cs (3)

237values.Add(Encoding.ASCII.GetString(data, offset, end - offset)); 248names.Add(Encoding.ASCII.GetString(data, pos, end - pos)); 300return Encoding.ASCII.GetString(buffer, pos, end - pos);

System\Data\SQLTypes\SQLString.cs (4)

129Encoding cpe = System.Text.Encoding.GetEncoding(culInfo.TextInfo.ANSICodePage); 334Encoding cpe = System.Text.Encoding.GetEncoding(culInfo.TextInfo.ANSICodePage);

System\Data\SQLTypes\SqlXml.cs (1)

182writerSettings.Encoding = Encoding.GetEncoding("utf-16");

System\Data\Odbc\OdbcConnection.cs (4)

399value = (BitConverter.IsLittleEndian ? Encoding.Unicode : Encoding.BigEndianUnicode).GetString(buffer, 0, Math.Min(cbActual, buffer.Length)); 501value = (BitConverter.IsLittleEndian ? Encoding.Unicode : Encoding.BigEndianUnicode).GetString(buffer, 0, Math.Min(cbActual, buffer.Length));

System\Data\Odbc\OdbcParameter.cs (6)

370cch = System.Text.Encoding.Default.GetMaxByteCount(cch); 384cch = System.Text.Encoding.Default.GetMaxByteCount(cch); 744Encoding cpe = System.Text.Encoding.GetEncoding(culInfo.TextInfo.ANSICodePage); 971Encoding cpe = System.Text.Encoding.GetEncoding(culInfo.TextInfo.ANSICodePage);

OleDbConnectionString.cs (2)

318else if (System.Text.Encoding.Unicode.GetString(bytes, 0, hdrlength) != UDL.Header) 326connectionString = System.Text.Encoding.Unicode.GetString(bytes, 0, count);

System\Diagnostics\PerformanceCounterLib.cs (1)

416StreamWriter iniWriter = new StreamWriter(IniFilePath, false, Encoding.Unicode);

System\Diagnostics\SharedPerformanceCounter.cs (1)

686string counter = new string((sbyte*)counterNamesPtr, start, i - start, Encoding.Unicode);

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

48internal AsyncStreamReader(Stream stream, Action<string?> callback, Encoding encoding)

System\Diagnostics\Process.Linux.cs (1)

296string argString = Encoding.UTF8.GetString(arg.Slice(nameStart));

System\Diagnostics\Process.Multiplexing.cs (12)

57Encoding outputEncoding = _startInfo?.StandardOutputEncoding ?? GetStandardOutputEncoding(); 58Encoding errorEncoding = _startInfo?.StandardErrorEncoding ?? GetStandardOutputEncoding(); 154Encoding outputEncoding = _startInfo?.StandardOutputEncoding ?? GetStandardOutputEncoding(); 155Encoding errorEncoding = _startInfo?.StandardErrorEncoding ?? GetStandardOutputEncoding(); 202private static int SkipPreambleOrDetectEncoding(ReadOnlySpan<byte> byteBuffer, ref Encoding encoding, ref Decoder decoder) 220encoding = Encoding.BigEndianUnicode; 229encoding = Encoding.UTF32; 234encoding = Encoding.Unicode; 241encoding = Encoding.UTF8; 350private static bool FlushDecoderAndEmitRemainingChars(bool preambleChecked, Encoding encoding, Decoder decoder, ReadOnlySpan<byte> unconsumedBytes, ref char[] charBuffer, ref int charStart, ref int charEnd, bool standardError, List<ProcessOutputLine> lines) 389Encoding outputEncoding = _startInfo?.StandardOutputEncoding ?? GetStandardOutputEncoding(); 390Encoding errorEncoding = _startInfo?.StandardErrorEncoding ?? GetStandardOutputEncoding();

System\Diagnostics\Process.Multiplexing.Unix.cs (3)

25Encoding outputEncoding, 26Encoding errorEncoding) 217ref Encoding encoding,

System\Diagnostics\Process.Unix.cs (4)

491private static Encoding GetStandardInputEncoding() => Encoding.Default; 493private static Encoding GetStandardOutputEncoding() => Encoding.Default;

System\Diagnostics\ProcessStartInfo.cs (3)

319public Encoding? StandardInputEncoding { get; set; } 321public Encoding? StandardErrorEncoding { get; set; } 323public Encoding? StandardOutputEncoding { get; set; }

System\DirectoryServices\Protocols\common\AsnWriterExtensions.cs (1)

11public static void WriteStringAsOctetString(this AsnWriter writer, string value, Encoding stringEncoding, Asn1Tag? tag = null)

System\DirectoryServices\Protocols\common\DirectoryControl.cs (1)

589writer.WriteStringAsOctetString(ServerName, Encoding.Unicode);

System\Formats\Asn1\AsnCharacterStringEncodings.cs (2)

19internal static Encoding GetEncoding(UniversalTagNumber encodingType) => 368private static readonly Encoding s_latin1Encoding = GetEncoding("iso-8859-1");

System\Formats\Asn1\AsnDecoder.Text.cs (4)

249Encoding encoding = AsnCharacterStringEncodings.GetEncoding(encodingType); 320Encoding encoding = AsnCharacterStringEncodings.GetEncoding(encodingType); 390Encoding encoding, 428Encoding encoding,

System\Formats\Asn1\AsnWriter.Text.cs (3)

76Encoding encoding = AsnCharacterStringEncodings.GetEncoding(encodingType); 81private void WriteCharacterStringCore(Asn1Tag tag, Encoding encoding, ReadOnlySpan<char> str) 113private void WriteConstructedCerCharacterString(Asn1Tag tag, Encoding encoding, ReadOnlySpan<char> str, int size)

System\Formats\Cbor\CborConformanceLevel.cs (1)

117public static Encoding GetUtf8Encoding(CborConformanceMode conformanceMode)

System\Formats\Cbor\Reader\CborReader.String.cs (8)

191Encoding utf8Encoding = CborConformanceModeHelpers.GetUtf8Encoding(ConformanceMode); 237Encoding utf8Encoding = CborConformanceModeHelpers.GetUtf8Encoding(ConformanceMode); 282Encoding encoding = CborConformanceModeHelpers.GetUtf8Encoding(ConformanceMode); 381Encoding utf8Encoding = CborConformanceModeHelpers.GetUtf8Encoding(ConformanceMode); 399static void BuildString(Span<char> target, (List<(int Offset, int Length)> ranges, ReadOnlyMemory<byte> source, Encoding utf8Encoding) input) 417Encoding utf8Encoding = CborConformanceModeHelpers.GetUtf8Encoding(ConformanceMode); 502Encoding utf8Encoding = CborConformanceModeHelpers.GetUtf8Encoding(ConformanceMode); 510private static int ValidateUtf8AndGetCharCount(ReadOnlySpan<byte> buffer, Encoding utf8Encoding)

System\Formats\Cbor\Writer\CborWriter.String.cs (1)

125Encoding utf8Encoding = CborConformanceModeHelpers.GetUtf8Encoding(ConformanceMode);

System\Formats\Tar\TarHeader.Read.cs (4)

537_magic = Encoding.ASCII.GetString(magic); 590_version = Encoding.ASCII.GetString(version); 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.Async.cs (1)

67public static async Task<ZipArchive> CreateAsync(Stream stream, ZipArchiveMode mode, bool leaveOpen, Encoding? entryNameEncoding, CancellationToken cancellationToken = default)

System\IO\Compression\ZipArchive.cs (8)

35private Encoding? _entryNameAndCommentEncoding; 124public ZipArchive(Stream stream, ZipArchiveMode mode, bool leaveOpen, Encoding? entryNameEncoding) 184private ZipArchive(ZipArchiveMode mode, bool leaveOpen, Encoding? entryNameEncoding, Stream? backingStream, Stream archiveStream) 208/// The comment encoding is determined by the <c>entryNameEncoding</c> parameter of the <see cref="ZipArchive(Stream,ZipArchiveMode,bool,Encoding?)"/> constructor. 214get => (EntryNameAndCommentEncoding ?? Encoding.UTF8).GetString(_archiveComment); 411internal Encoding? EntryNameAndCommentEncoding 433(value.Equals(Encoding.BigEndianUnicode) 434|| value.Equals(Encoding.Unicode)))

System\IO\Compression\ZipArchiveEntry.cs (4)

291///The comment encoding is determined by the <c>entryNameEncoding</c> parameter of the <see cref="ZipArchive(Stream,ZipArchiveMode,bool,Encoding?)"/> constructor. 586Encoding readEntryStringEncoding = 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 (4)

22internal static Encoding GetEncoding(string text) 29return Encoding.UTF8; 32return Encoding.ASCII; 190internal static byte[] GetEncodedTruncatedBytesFromString(string? text, Encoding? encoding, int maxBytes, out bool isUTF8)

System\IO\Compression\ZipExtractionOptions.cs (1)

21public Encoding? EntryNameEncoding { get; set; }

System\IO\Compression\ZipFile.Create.Async.cs (5)

155public static async Task<ZipArchive> OpenAsync(string archiveFileName, ZipArchiveMode mode, Encoding? entryNameEncoding, CancellationToken cancellationToken = default) 341CompressionLevel compressionLevel, bool includeBaseDirectory, Encoding? entryNameEncoding, CancellationToken cancellationToken = default) => 430CompressionLevel compressionLevel, bool includeBaseDirectory, Encoding? entryNameEncoding, CancellationToken cancellationToken = default) => 488CompressionLevel? compressionLevel, bool includeBaseDirectory, Encoding? entryNameEncoding, CancellationToken cancellationToken) 507CompressionLevel? compressionLevel, bool includeBaseDirectory, Encoding? entryNameEncoding, CancellationToken cancellationToken)

System\IO\Compression\ZipFile.Create.cs (5)

144public static ZipArchive Open(string archiveFileName, ZipArchiveMode mode, Encoding? entryNameEncoding) 319CompressionLevel compressionLevel, bool includeBaseDirectory, Encoding? entryNameEncoding) => 400CompressionLevel compressionLevel, bool includeBaseDirectory, Encoding? entryNameEncoding) => 448CompressionLevel? compressionLevel, bool includeBaseDirectory, Encoding? entryNameEncoding) 462CompressionLevel? compressionLevel, bool includeBaseDirectory, Encoding? entryNameEncoding)

System\IO\Compression\ZipFile.Extract.Async.cs (6)

137public static Task ExtractToDirectoryAsync(string sourceArchiveFileName, string destinationDirectoryName, Encoding? entryNameEncoding, CancellationToken cancellationToken = default) => 195public static async Task ExtractToDirectoryAsync(string sourceArchiveFileName, string destinationDirectoryName, Encoding? entryNameEncoding, bool overwriteFiles, CancellationToken cancellationToken = default) 264private static async Task ExtractToDirectoryAsync(string sourceArchiveFileName, string destinationDirectoryName, Encoding? entryNameEncoding, bool overwriteFiles, ReadOnlyMemory<char> password, CancellationToken cancellationToken = default) 381public static Task ExtractToDirectoryAsync(Stream source, string destinationDirectoryName, Encoding? entryNameEncoding, CancellationToken cancellationToken = default) => 422public static async Task ExtractToDirectoryAsync(Stream source, string destinationDirectoryName, Encoding? entryNameEncoding, bool overwriteFiles, CancellationToken cancellationToken = default) 478private static async Task ExtractToDirectoryAsync(Stream source, string destinationDirectoryName, Encoding? entryNameEncoding, bool overwriteFiles, ReadOnlyMemory<char> password, CancellationToken cancellationToken = default)

System\IO\Compression\ZipFile.Extract.cs (6)

126public static void ExtractToDirectory(string sourceArchiveFileName, string destinationDirectoryName, Encoding? entryNameEncoding) => 181public static void ExtractToDirectory(string sourceArchiveFileName, string destinationDirectoryName, Encoding? entryNameEncoding, bool overwriteFiles) 244private static void ExtractToDirectory(string sourceArchiveFileName, string destinationDirectoryName, Encoding? entryNameEncoding, bool overwriteFiles, ReadOnlySpan<char> password) 346public static void ExtractToDirectory(Stream source, string destinationDirectoryName, Encoding? entryNameEncoding) => 384public static void ExtractToDirectory(Stream source, string destinationDirectoryName, Encoding? entryNameEncoding, bool overwriteFiles) 432private static void ExtractToDirectory(Stream source, string destinationDirectoryName, Encoding? entryNameEncoding, bool overwriteFiles, ReadOnlySpan<char> password)

System\IO\Compression\ZipFileCreationOptions.cs (1)

31public Encoding? EntryNameEncoding { get; set; }

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\IO\Ports\SerialPort.cs (5)

43private Encoding _encoding = Encoding.ASCII; // ASCII is default encoding for modem communication, etc. 44private Decoder _decoder = Encoding.ASCII.GetDecoder(); 45private int _maxByteCountForSingleChar = Encoding.ASCII.GetMaxByteCount(1); 293public Encoding Encoding

System\Management\WMIGenerator.cs (1)

185tw = new StreamWriter(new FileStream(filePath, FileMode.Create), System.Text.Encoding.UTF8);

System\Text\EncodingExtensions.cs (24)

System\BinaryData.cs (2)

144_bytes = Encoding.UTF8.GetBytes(data); 419public override string ToString() => Encoding.UTF8.GetString(_bytes.Span);

src\runtime\src\libraries\Common\src\System\Net\Http\aspnetcore\Http2\Hpack\H2StaticTable.Http2.cs (2)

102Encoding.ASCII.GetBytes(name), 103value.Length != 0 ? Encoding.ASCII.GetBytes(value) : Array.Empty<byte>());

src\runtime\src\libraries\Common\src\System\Net\Http\aspnetcore\Http2\Hpack\HeaderField.cs (2)

45return Encoding.Latin1.GetString(Name) + ": " + Encoding.Latin1.GetString(Value);

src\runtime\src\libraries\Common\src\System\Net\Http\aspnetcore\Http2\Hpack\HPackEncoder.cs (12)

src\runtime\src\libraries\Common\src\System\Net\Http\aspnetcore\Http2\Hpack\StatusCodes.cs (1)

145return Encoding.ASCII.GetBytes(statusCode.ToString(CultureInfo.InvariantCulture));

src\runtime\src\libraries\Common\src\System\Net\Http\aspnetcore\Http3\QPack\H3StaticTable.Http3.cs (2)

142=> new HeaderField(Encoding.ASCII.GetBytes(name), Encoding.ASCII.GetBytes(value));

src\runtime\src\libraries\Common\src\System\Net\Http\aspnetcore\Http3\QPack\HeaderField.cs (2)

35return Encoding.ASCII.GetString(Name) + ": " + Encoding.ASCII.GetString(Value);

src\runtime\src\libraries\Common\src\System\Net\Http\aspnetcore\Http3\QPack\QPackEncoder.cs (9)

66public static bool EncodeLiteralHeaderFieldWithStaticNameReference(int index, string value, Encoding? valueEncoding, Span<byte> destination, out int bytesWritten) 89/// Encodes just the name part of a Literal Header Field With Static Name Reference. Must call <see cref="EncodeValueString(string, Encoding?, Span{byte}, out int)"/> after to encode the header's value. 130public static bool EncodeLiteralHeaderFieldWithoutNameReference(string name, string value, Encoding? valueEncoding, Span<byte> destination, out int bytesWritten) 147public static bool EncodeLiteralHeaderFieldWithoutNameReference(string name, ReadOnlySpan<string> values, byte[] separator, Encoding? valueEncoding, Span<byte> destination, out int bytesWritten) 160/// Encodes just the value part of a Literawl Header Field Without Static Name Reference. Must call <see cref="EncodeValueString(string, Encoding?, Span{byte}, out int)"/> after to encode the header's value. 182private static bool EncodeValueString(string s, Encoding? valueEncoding, Span<byte> buffer, out int length) 188int encodedStringLength = valueEncoding is null || ReferenceEquals(valueEncoding, Encoding.Latin1) 220public static bool EncodeValueString(ReadOnlySpan<string> values, byte[]? separator, Encoding? valueEncoding, Span<byte> buffer, out int length) 239if (valueEncoding is null || ReferenceEquals(valueEncoding, Encoding.Latin1))

System\Net\Http\HeaderEncodingSelector.cs (4)

9/// Represents a method that specifies the <see cref="Encoding"/> to use when interpreting header values. 11/// <param name="headerName">Name of the header to specify the <see cref="Encoding"/> for.</param> 14/// <returns><see cref="Encoding"/> to use or <see langword="null"/> to use the default behavior.</returns> 15public delegate Encoding? HeaderEncodingSelector<TContext>(string headerName, TContext context);

System\Net\Http\Headers\ContentDispositionHeaderValue.cs (5)

439byte[] buffer = Encoding.UTF8.GetBytes(input); 473Encoding encoding = Encoding.GetEncoding(processedInput[parts[1]]); 514Encoding encoding = Encoding.GetEncoding(encodingString);

System\Net\Http\Headers\HeaderDescriptor.cs (1)

134public string GetHeaderValue(ReadOnlySpan<byte> headerValue, Encoding? valueEncoding)

System\Net\Http\Headers\HeaderUtilities.cs (3)

71byte[] utf8bytes = ArrayPool<byte>.Shared.Rent(Encoding.UTF8.GetMaxByteCount(input.Length)); 72int utf8length = Encoding.UTF8.GetBytes(input, 0, input.Length, utf8bytes, 0); 85Encoding.ASCII.GetChars(utf8.Slice(0, length), builder.AppendSpan(length));

System\Net\Http\Headers\HttpHeaderParser.cs (1)

41SeparatorBytes = Encoding.ASCII.GetBytes(separator);

System\Net\Http\Headers\KnownHeader.cs (1)

28int asciiBytes = Encoding.ASCII.GetBytes(name, asciiBytesWithColonSpace);

System\Net\Http\Headers\UriHeaderParser.cs (2)

78Encoding decoder = Encoding.GetEncoding("utf-8", EncoderFallback.ExceptionFallback, DecoderFallback.ExceptionFallback);

System\Net\Http\HttpContent.cs (16)

26internal static readonly Encoding DefaultStringEncoding = Encoding.UTF8; 42AssertEncodingConstants(Encoding.UTF8, UTF8CodePage, UTF8Preamble); 45AssertEncodingConstants(Encoding.UTF32, UTF32CodePage, UTF32Preamble); 47AssertEncodingConstants(Encoding.Unicode, UnicodeCodePage, UnicodePreamble); 49AssertEncodingConstants(Encoding.BigEndianUnicode, BigEndianUnicodeCodePage, BigEndianUnicodePreamble); 52private static void AssertEncodingConstants(Encoding encoding, int codePage, ReadOnlySpan<byte> preamble) 128Encoding? encoding = null; 144encoding = Encoding.GetEncoding(charset.Substring(1, charset.Length - 2)); 148encoding = Encoding.GetEncoding(charset); 711private static int GetPreambleLength(ReadOnlySpan<byte> data, Encoding encoding) 735private static bool TryDetectEncoding(ReadOnlySpan<byte> data, [NotNullWhen(true)] out Encoding? encoding, out int preambleLength) 739encoding = Encoding.UTF8; 746encoding = Encoding.UTF32; 753encoding = Encoding.Unicode; 760encoding = Encoding.BigEndianUnicode;

System\Net\Http\HttpRuleParser.cs (3)

34internal static Encoding DefaultHttpEncoding => Encoding.Latin1; 57return Encoding.ASCII.GetString(input);

System\Net\Http\MultipartContent.cs (4)

145/// Gets or sets a callback that returns the <see cref="Encoding"/> to decode the value for the specified response header name, 320Encoding headerValueEncoding = HeaderEncodingSelector?.Invoke(headerPair.Key, content) ?? HttpRuleParser.DefaultHttpEncoding; 366Encoding headerValueEncoding = HeaderEncodingSelector?.Invoke(headerPair.Key, content) ?? HttpRuleParser.DefaultHttpEncoding; 632private static void WriteToStream(Stream stream, string content, Encoding encoding)

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

389throw new HttpIOException(HttpRequestError.InvalidResponse, SR.Format(SR.net_http_invalid_response_chunk_terminator_invalid, Encoding.ASCII.GetString(currentLine)));

System\Net\Http\SocketsHttpHandler\ConnectionPool\HttpConnectionPool.cs (2)

203Encoding.ASCII.GetBytes(hostHeader, hostHeaderLine.AsSpan(6)); 208Debug.Assert(Encoding.ASCII.GetString(_hostHeaderLineBytes) == $"Host: {hostHeader}\r\n");

System\Net\Http\SocketsHttpHandler\ConnectionPool\HttpConnectionPool.Http2.cs (1)

64_http2AltSvcOriginUri = Encoding.ASCII.GetBytes(sb.ToString());

System\Net\Http\SocketsHttpHandler\Http2Connection.cs (9)

457string response = Encoding.ASCII.GetString(_incomingBuffer.ActiveSpan.Slice(0, Math.Min(20, _incomingBuffer.ActiveLength))); 783string altSvcHeaderValue = Encoding.ASCII.GetString(span); 1434private void WriteLiteralHeader(string name, ReadOnlySpan<string> values, Encoding? valueEncoding, ref ArrayBuffer headerBuffer) 1447private void WriteLiteralHeaderValues(ReadOnlySpan<string> values, byte[]? separator, Encoding? valueEncoding, ref ArrayBuffer headerBuffer) 1449if (NetEventSource.Log.IsEnabled()) Trace($"{nameof(values)}={string.Join(Encoding.ASCII.GetString(separator ?? []), values)}"); 1460private void WriteLiteralHeaderValue(string value, Encoding? valueEncoding, ref ArrayBuffer headerBuffer) 1499Encoding? valueEncoding = encodingSelector?.Invoke(header.Key.Name, request); 1595Encoding? protocolEncoding = _pool.Settings._requestHeaderEncodingSelector?.Invoke(":protocol", request); 1610Encoding? cookieEncoding = _pool.Settings._requestHeaderEncodingSelector?.Invoke(KnownHeaders.Cookie.Name, request);

System\Net\Http\SocketsHttpHandler\Http2Stream.cs (4)

679if (NetEventSource.Log.IsEnabled()) Trace($"{descriptor.Name}: {Encoding.ASCII.GetString(value)}"); 704Encoding? valueEncoding = _connection._pool.Settings._responseHeaderEncodingSelector?.Invoke(descriptor.Name, _request); 744if (NetEventSource.Log.IsEnabled()) Trace($"Invalid response pseudo-header '{Encoding.ASCII.GetString(name)}'."); 754throw new HttpRequestException(HttpRequestError.InvalidResponse, SR.Format(SR.net_http_invalid_response_header_name, Encoding.ASCII.GetString(name)));

System\Net\Http\SocketsHttpHandler\Http3RequestStream.cs (9)

725Encoding? valueEncoding = _connection.Pool.Settings._requestHeaderEncodingSelector?.Invoke(HttpKnownHeaderNames.Cookie, request); 784Encoding? valueEncoding = encodingSelector?.Invoke(header.Key.Name, _request); 841private void BufferLiteralHeaderWithStaticNameReference(int nameIndex, string value, Encoding? valueEncoding = null) 851private void BufferLiteralHeaderWithoutNameReference(string name, ReadOnlySpan<string> values, byte[] separator, Encoding? valueEncoding) 861private void BufferLiteralHeaderWithoutNameReference(string name, string value, Encoding? valueEncoding) 871private void BufferLiteralHeaderValues(ReadOnlySpan<string> values, byte[]? separator, Encoding? valueEncoding) 997throw new HttpRequestException(HttpRequestError.InvalidResponse, SR.Format(SR.net_http_invalid_response_header_name, Encoding.ASCII.GetString(name))); 1086return HttpConnectionBase.ParseStatusCode(Encoding.ASCII.GetBytes(value)); 1136Encoding? encoding = _connection.Pool.Settings._responseHeaderEncodingSelector?.Invoke(descriptor.Name, _request);

System\Net\Http\SocketsHttpHandler\HttpConnection.cs (10)

440Encoding? valueEncoding = encodingSelector?.Invoke(header.Key.Name, _currentRequest); 503private void WriteString(string s, Encoding? encoding) 1070throw new HttpRequestException(HttpRequestError.InvalidResponse, SR.Format(SR.net_http_invalid_response_status_line, Encoding.ASCII.GetString(line))); 1091throw new HttpRequestException(HttpRequestError.InvalidResponse, SR.Format(SR.net_http_invalid_response_status_line, Encoding.ASCII.GetString(line))); 1099throw new HttpRequestException(HttpRequestError.InvalidResponse, SR.Format(SR.net_http_invalid_response_status_code, Encoding.ASCII.GetString(line.Slice(9, 3)))); 1124throw new HttpRequestException(HttpRequestError.InvalidResponse, SR.Format(SR.net_http_invalid_response_status_reason, Encoding.ASCII.GetString(reasonBytes.ToArray())), formatEx); 1130throw new HttpRequestException(HttpRequestError.InvalidResponse, SR.Format(SR.net_http_invalid_response_status_line, Encoding.ASCII.GetString(line))); 1229throw new HttpRequestException(HttpRequestError.InvalidResponse, SR.Format(SR.net_http_invalid_response_header_line, Encoding.ASCII.GetString(buffer.Slice(0, newLineIndex)))); 1281Encoding? valueEncoding = _pool.Settings._responseHeaderEncodingSelector?.Invoke(descriptor.Name, _currentRequest!); 1331throw new HttpRequestException(HttpRequestError.InvalidResponse, SR.Format(SR.net_http_invalid_response_header_name, Encoding.ASCII.GetString(name)));

System\Net\Http\SocketsHttpHandler\HttpConnectionBase.cs (3)

190public string GetResponseHeaderValueWithCaching(HeaderDescriptor descriptor, ReadOnlySpan<byte> value, Encoding? valueEncoding) 197static string GetOrAddCachedValue([NotNull] ref string? cache, HeaderDescriptor descriptor, ReadOnlySpan<byte> value, Encoding? encoding) 306throw new HttpRequestException(HttpRequestError.InvalidResponse, SR.Format(SR.net_http_invalid_response_status_code, Encoding.ASCII.GetString(value)));

System\Net\Http\SocketsHttpHandler\SocketsHttpHandler.cs (2)

507/// Gets or sets a callback that returns the <see cref="Encoding"/> to encode the value for the specified request header name, 521/// Gets or sets a callback that returns the <see cref="Encoding"/> to decode the value for the specified response header name,

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

39public StringContent(string content, Encoding? encoding) 48public StringContent(string content, Encoding? encoding, string? mediaType) 80public StringContent(string content, Encoding? encoding, MediaTypeHeaderValue? mediaType) 90private static byte[] GetContentByteArray(string content, Encoding? encoding)

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

136return JsonHelpers.GetEncoding(content) is Encoding sourceEncoding && sourceEncoding != Encoding.UTF8 141private static async ValueTask<Stream> GetTranscodingStreamAsync(Task<Stream> task, Encoding sourceEncoding)

System\Net\Http\Json\HttpContentJsonExtensions.netcoreapp.cs (3)

18private static Stream GetTranscodingStream(Stream contentStream, Encoding sourceEncoding) 20return Encoding.CreateTranscodingStream(contentStream, innerStreamEncoding: sourceEncoding, outerStreamEncoding: Encoding.UTF8);

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

115Encoding? targetEncoding = JsonHelpers.GetEncoding(this); 117return targetEncoding != null && targetEncoding != Encoding.UTF8 122private async Task SerializeToStreamAsyncTranscoding(Stream targetStream, bool async, Encoding targetEncoding, CancellationToken cancellationToken) 126Stream transcodingStream = Encoding.CreateTranscodingStream(targetStream, targetEncoding, Encoding.UTF8, leaveOpen: true);

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

16if (JsonHelpers.GetEncoding(this) is Encoding targetEncoding && targetEncoding != Encoding.UTF8)

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

30internal static Encoding? GetEncoding(HttpContent content) 32Encoding? encoding = null; 41encoding = Encoding.GetEncoding(charset.Substring(1, charset.Length - 2)); 45encoding = Encoding.GetEncoding(charset);

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

70public Encoding ContentEncoding 81return Encoding.GetEncoding(postDataCharset); 97return Encoding.GetEncoding(charSet); 105return Encoding.Default; 410private static string UrlDecodeStringFromStringInternal(string s, Encoding e) 485private readonly Encoding _encoding; 496internal UrlDecoder(int bufferSize, Encoding encoding) 533internal static void FillFromString(NameValueCollection nvc, string s, bool urlencoded, Encoding encoding)

System\Net\HttpListenerRequestUriBuilder.cs (7)

19private static readonly Encoding s_ansiEncoding = Encoding.GetEncoding(0, new EncoderExceptionFallback(), new DecoderExceptionFallback()); 107Encoding secondaryEncoding = GetEncoding(EncodingType.Secondary); 120private static Encoding GetEncoding(EncodingType type) 134private ParsingResult BuildRequestUriUsingRawPath(Encoding encoding) 170private ParsingResult ParseRawPath(Encoding encoding) 294private bool EmptyDecodeAndAppendRawOctetsList(Encoding encoding)

System\Net\HttpListenerResponse.cs (1)

34public Encoding? ContentEncoding { get; set; }

System\Net\Managed\HttpConnection.cs (1)

463byte[] error = Encoding.Default.GetBytes(str);

System\Net\Managed\HttpListenerContext.Managed.cs (1)

67string authString = Encoding.UTF8.GetString(Convert.FromBase64String(headerValue));

System\Net\Managed\HttpListenerResponse.Managed.cs (3)

269Encoding encoding = Encoding.Default; 273byte[] statusDescriptionBytes = Encoding.Latin1.GetBytes(StatusDescription);

System\Net\Managed\HttpResponseStream.Managed.cs (1)

132Encoding.ASCII.GetBytes($"{size:x}\r\n{(final ? "\r\n" : "")}");

System\Net\WebSockets\HttpWebSocket.cs (1)

22byte[] toHash = Encoding.UTF8.GetBytes(acceptString);

System\Net\Base64Stream.cs (1)

136public int EncodeString(string value, Encoding encoding) => _encoder.EncodeString(value, encoding);

System\Net\BufferBuilder.cs (2)

78int byteCount = Encoding.UTF8.GetByteCount(value, offset, count); 80Encoding.UTF8.GetBytes(value, offset, count, _buffer, _offset);

System\Net\Mail\AlternateView.cs (1)

70public static AlternateView CreateAlternateViewFromString(string content, Encoding? contentEncoding, string? mediaType)

System\Net\Mail\Attachment.cs (13)

91Encoding encoding; 95encoding = Text.Encoding.GetEncoding(contentType.CharSet); 101encoding = Text.Encoding.ASCII; 105encoding = Text.Encoding.GetEncoding(MimeBasePart.DefaultCharSet); 121internal void SetContentFromString(string content, Encoding? encoding, string? mediaType) 157encoding = Encoding.ASCII; 161encoding = Encoding.GetEncoding(MimeBasePart.DefaultCharSet); 287private Encoding? _nameEncoding; 346Encoding encoding = NameEncoding ?? Encoding.GetEncoding(MimeBasePart.DefaultCharSet); 363Encoding? nameEncoding = MimeBasePart.DecodeEncoding(value); 380public Encoding? NameEncoding 421public static Attachment CreateAttachmentFromString(string content, string? name, Encoding? contentEncoding, string? mediaType)

System\Net\Mail\LinkedResource.cs (1)

59public static LinkedResource CreateLinkedResourceFromString(string content, Encoding? contentEncoding, string? mediaType)

System\Net\Mail\MailAddress.cs (13)

20private readonly Encoding _displayNameEncoding; 27internal MailAddress(string displayName, string userName, string domain, Encoding? displayNameEncoding) 32_displayNameEncoding = displayNameEncoding ?? Encoding.GetEncoding(MimeBasePart.DefaultCharSet); 44public MailAddress(string address) : this(address, null, (Encoding?)null) 48public MailAddress(string address, string? displayName) : this(address, displayName, (Encoding?)null) 65public MailAddress(string address, string? displayName, Encoding? displayNameEncoding) 68out (string displayName, string user, string host, Encoding displayNameEncoding) parsedData, 101/// <param name="displayNameEncoding">The <see cref="Encoding"/> that defines the character set used for displayName</param> 104public static bool TryCreate([NotNullWhen(true)] string? address, string? displayName, Encoding? displayNameEncoding, [NotNullWhen(true)] out MailAddress? result) 107out (string displayName, string user, string host, Encoding displayNameEncoding) parsed, 120private static bool TryParse([NotNullWhen(true)] string? address, string? displayName, Encoding? displayNameEncoding, out (string displayName, string user, string host, Encoding displayNameEncoding) parsedData, bool throwExceptionIfFail) 132displayNameEncoding ??= Encoding.GetEncoding(MimeBasePart.DefaultCharSet);

System\Net\Mail\MailMessage.cs (6)

31private Encoding? _bodyEncoding; 182public Encoding? SubjectEncoding 202public Encoding? HeadersEncoding 230_bodyEncoding = Text.Encoding.ASCII; 234_bodyEncoding = Text.Encoding.GetEncoding(MimeBasePart.DefaultCharSet); 240public Encoding? BodyEncoding

System\Net\Mail\MailPriority.cs (9)

32private Encoding? _subjectEncoding; 33private Encoding? _headersEncoding; 135Encoding? inputEncoding = null; 168_subjectEncoding = Encoding.GetEncoding(MimeBasePart.DefaultCharSet); 174internal Encoding? SubjectEncoding 200internal Encoding? HeadersEncoding 269_headersEncoding ??= Encoding.GetEncoding(MimeBasePart.DefaultCharSet); 300_headersEncoding ??= Encoding.GetEncoding(MimeBasePart.DefaultCharSet); 406_headersEncoding ??= Encoding.GetEncoding(MimeBasePart.DefaultCharSet);

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

15public string GetEncodedString() => Encoding.ASCII.GetString(WriteState.Buffer, 0, WriteState.Length); 54public int EncodeString(string value, Encoding encoding) 61if (encoding == Encoding.Latin1) // we don't need to check for codepoints

System\Net\Mime\ContentDisposition.cs (2)

226Encoding? encoding = MimeBasePart.DecodeEncoding(value); 239encoding = Encoding.GetEncoding(MimeBasePart.DefaultCharSet);

System\Net\Mime\ContentType.cs (3)

119Encoding? nameEncoding = MimeBasePart.DecodeEncoding(value); 194Encoding? encoding = MimeBasePart.DecodeEncoding(value); 207encoding = Encoding.GetEncoding(MimeBasePart.DefaultCharSet);

System\Net\Mime\EightBitStream.cs (1)

171public int EncodeString(string value, Encoding encoding) { throw new NotImplementedException(); }

System\Net\Mime\EncodedStreamFactory.cs (3)

20internal static IEncodableStream GetEncoderForHeader(Encoding encoding, bool useBase64Encoding, int headerTextLength) 39private static byte[] CreateHeader(Encoding encoding, bool useBase64Encoding) => 40Encoding.ASCII.GetBytes("=?" + encoding.HeaderName + "?" + (useBase64Encoding ? "B?" : "Q?"));

System\Net\Mime\IByteEncoder.cs (1)

13int EncodeString(string value, Encoding encoding);

System\Net\Mime\IEncodableStream.cs (1)

13int EncodeString(string value, Encoding encoding);

System\Net\Mime\MimeBasePart.cs (14)

22internal static bool ShouldUseBase64Encoding(Encoding? encoding) => 23encoding == Encoding.Unicode || encoding == Encoding.UTF8 || encoding == Encoding.UTF32 || encoding == Encoding.BigEndianUnicode; 26internal static string EncodeHeaderValue(string value, Encoding encoding, bool base64Encoding) => 30internal static string EncodeHeaderValue(string value, Encoding? encoding, bool base64Encoding, int headerLength) 38encoding ??= Encoding.GetEncoding(DefaultCharSet); 76byte[] buffer = Encoding.ASCII.GetBytes(subStrings[3]); 79IEncodableStream s = EncodedStreamFactory.GetEncoderForHeader(Encoding.GetEncoding(charSet), base64Encoding, 0); 83Encoding encoding = Encoding.GetEncoding(charSet); 93internal static unsafe Encoding? DecodeEncoding(string? value) 109return Encoding.GetEncoding(value[subStrings[1]]);

System\Net\Mime\MimeWriter.cs (1)

25_boundaryBytes = Encoding.ASCII.GetBytes(boundary);

System\Net\Mime\QEncodedStream.cs (1)

184public int EncodeString(string value, Encoding encoding) => _encoder.EncodeString(value, encoding);

System\Net\Mime\QuotedPrintableStream.cs (2)

294public int EncodeString(string value, Encoding encoding) 300public string GetEncodedString() => Encoding.ASCII.GetString(WriteState.Buffer, 0, WriteState.Length);

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

471private Encoding _encoding = Encoding.UTF8; 474protected Encoding Encoding

System\Net\FtpControlStream.cs (2)

289Encoding = Encoding.UTF8; 293Encoding = Encoding.Default;

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.ManagedNtlm.cs (9)

System\Net\NegotiateAuthenticationPal.Unix.cs (1)

534return Encoding.UTF8.GetString(tokenBytes);

System\Net\Security\CipherSuitesPolicyPal.Linux.cs (1)

199public OpenSslStringBuilder() : base(new MemoryStream(), Encoding.ASCII)

System\Net\Security\SslApplicationProtocol.cs (3)

12private static readonly Encoding s_utf8 = Encoding.GetEncoding(Encoding.UTF8.CodePage, EncoderFallback.ExceptionFallback, DecoderFallback.ExceptionFallback);

System\Net\Security\TlsFrameHelper.cs (2)

167private static readonly Encoding s_encoding = Encoding.GetEncoding("utf-8", new EncoderExceptionFallback(), new DecoderExceptionFallback());

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

33private Encoding _encoding = Encoding.Default; 142public Encoding Encoding 510formHeaderBytes = Encoding.UTF8.GetBytes(formHeader); 613byte[] buffer = Encoding.ASCII.GetBytes(values.ToString()); 1086private static readonly Encoding[] s_knownEncodings = { Encoding.UTF8, Encoding.UTF32, Encoding.Unicode, Encoding.BigEndianUnicode }; 1090Encoding? enc = null; 1120enc = Encoding.GetEncoding(item); 1138foreach (Encoding encoding in s_knownEncodings)

System\Net\WebHeaderCollection.cs (1)

415return System.Text.Encoding.ASCII.GetBytes(tempString);

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\CodeDom\Compiler\IndentedTextWriter.cs (1)

33public override Encoding Encoding => _writer.Encoding;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventPipePayloadDecoder.cs (1)

129decodedFields[i] = BitConverter.IsLittleEndian ? new string(charPayload) : Encoding.Unicode.GetString(MemoryMarshal.Cast<char, byte>(charPayload));

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

446return (manifestBytes == null) ? null : Encoding.UTF8.GetString(manifestBytes, 0, manifestBytes.Length); 1776int nameByteCount = Encoding.BigEndianUnicode.GetByteCount(name); 1781Encoding.BigEndianUnicode.GetBytes(name, source.Slice(namespaceBytes.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 (4)

20private readonly Encoding _encoding; 31public BinaryReader(Stream input) : this(input, Encoding.UTF8, false) 35public BinaryReader(Stream input, Encoding encoding) : this(input, encoding, false) 39public BinaryReader(Stream input, Encoding encoding, bool leaveOpen)

src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\BinaryWriter.cs (5)

23private readonly Encoding _encoding; 32_encoding = Encoding.UTF8; 37public BinaryWriter(Stream output) : this(output, Encoding.UTF8, false) 41public BinaryWriter(Stream output, Encoding encoding) : this(output, encoding, false) 45public BinaryWriter(Stream output, Encoding encoding, bool leaveOpen)

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

10internal static readonly Encoding UTF8NoBOM = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);

src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\File.cs (36)

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

31private readonly Encoding _encoding; 34private ReadLinesIterator(string path, Encoding encoding, StreamReader reader) 89internal static ReadLinesIterator CreateIterator(string path, Encoding encoding) 94private static ReadLinesIterator CreateIterator(string path, Encoding encoding, StreamReader? reader)

src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\StreamReader.cs (20)

32private Encoding _encoding = null!; // only null in NullStreamReader where this is never used 136: this(stream, Encoding.UTF8, detectEncodingFromByteOrderMarks, DefaultBufferSize, leaveOpen: false) 140public StreamReader(Stream stream, Encoding? encoding) 145public StreamReader(Stream stream, Encoding? encoding, bool detectEncodingFromByteOrderMarks) 160public StreamReader(Stream stream, Encoding? encoding, bool detectEncodingFromByteOrderMarks, int bufferSize) 165public StreamReader(Stream stream, Encoding? encoding = null, bool detectEncodingFromByteOrderMarks = true, int bufferSize = -1, bool leaveOpen = false) 184_encoding = encoding ??= Encoding.UTF8; 212: this(path, Encoding.UTF8, detectEncodingFromByteOrderMarks, DefaultBufferSize) 216public StreamReader(string path, Encoding? encoding) 221public StreamReader(string path, Encoding? encoding, bool detectEncodingFromByteOrderMarks) 226public StreamReader(string path, Encoding? encoding, bool detectEncodingFromByteOrderMarks, int bufferSize) 232: this(path, Encoding.UTF8, detectEncodingFromByteOrderMarks: true, options) 236public StreamReader(string path, Encoding? encoding, bool detectEncodingFromByteOrderMarks, FileStreamOptions options) 299public virtual Encoding CurrentEncoding => _encoding; 510_encoding = Encoding.BigEndianUnicode; 519_encoding = Encoding.Unicode; 525_encoding = Encoding.UTF32; 533_encoding = Encoding.UTF8; 1471public override Encoding CurrentEncoding => Encoding.Unicode;

src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\StreamWriter.cs (9)

33private readonly Encoding _encoding; 98private static Encoding UTF8NoBOM => EncodingCache.UTF8NoBOM; 105public StreamWriter(Stream stream, Encoding? encoding) 114public StreamWriter(Stream stream, Encoding? encoding, int bufferSize) 119public StreamWriter(Stream stream, Encoding? encoding = null, int bufferSize = -1, bool leaveOpen = false) 168public StreamWriter(string path, bool append, Encoding? encoding) 173public StreamWriter(string path, bool append, Encoding? encoding, int bufferSize) : 183public StreamWriter(string path, Encoding? encoding, FileStreamOptions options) 373public override Encoding Encoding => _encoding;

src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\StringStream.cs (4)

23private readonly Encoding _encoding; 43public StringStream(string text, Encoding encoding) 59public StringStream(ReadOnlyMemory<char> text, Encoding encoding) 71public Encoding Encoding => _encoding;

src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\StringWriter.cs (1)

58public override Encoding Encoding => field ??= new UnicodeEncoding(false, false);

src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\TextWriter.CreateBroadcasting.cs (1)

58public override Encoding Encoding => _writers[0].Encoding;

src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\TextWriter.cs (4)

94public abstract Encoding Encoding 814public override Encoding Encoding => Encoding.Unicode; 900public override Encoding Encoding => _out.Encoding;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Net\WebUtility.cs (6)

345int byteCount = Encoding.UTF8.GetByteCount(value); 351Encoding.UTF8.GetBytes(state.value, utf8Bytes); 447private static string? UrlDecodeInternal(string? value, Encoding encoding) 560return UrlDecodeInternal(encodedValue, Encoding.UTF8); 618private readonly Encoding _encoding; 629internal UrlDecoder(int bufferSize, Encoding encoding)

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

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); 439return Encoding.Unicode.GetString(bytes, 0, byteLen);

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

249return CreateStringFromEncoding(pb, numBytes, Encoding.UTF8); 258public extern unsafe String(sbyte* value, int startIndex, int length, Encoding enc); 260private static unsafe string Ctor(sbyte* value, int startIndex, int length, Encoding? enc) 538byte* bytes, int byteLength, Encoding encoding)

src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\DecoderFallback.cs (3)

64internal Encoding? _encoding; 83internal static DecoderFallbackBuffer CreateAndInitialize(Encoding encoding, DecoderNLS? decoder, int originalByteCount) 260Encoding.ThrowConversionOverflow();

src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\DecoderNLS.cs (2)

25private readonly Encoding _encoding; 32internal DecoderNLS(Encoding encoding)

src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\EncoderFallback.cs (3)

72private Encoding? encoding; 98internal static EncoderFallbackBuffer CreateAndInitialize(Encoding encoding, EncoderNLS? encoder, int originalCharCount) 270Encoding.ThrowConversionOverflow();

src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\EncoderNLS.cs (4)

27private readonly Encoding _encoding; 32internal EncoderNLS(Encoding encoding) 210public Encoding Encoding 222/// States whether a call to <see cref="Encoding.GetBytes(char*, int, byte*, int, EncoderNLS)"/> must first drain data on this <see cref="EncoderNLS"/> instance.

src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\Encoding.cs (40)

src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\Encoding.Internal.cs (2)

96/// Given a <see cref="Rune"/>, determines its byte count under the current <see cref="Encoding"/>. 98/// current <see cref="Encoding"/>.

src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\EncodingData.cs (4)

241private const uint MIMECONTF_MAILNEWS = Encoding.MIMECONTF_MAILNEWS; 242private const uint MIMECONTF_BROWSER = Encoding.MIMECONTF_BROWSER; 243private const uint MIMECONTF_SAVABLE_MAILNEWS = Encoding.MIMECONTF_SAVABLE_MAILNEWS; 244private const uint MIMECONTF_SAVABLE_BROWSER = Encoding.MIMECONTF_SAVABLE_BROWSER;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\EncodingInfo.cs (4)

53/// Get the <see cref="Encoding"/> object match the information in the <see cref="EncodingInfo"/> object 55/// <returns>The <see cref="Encoding"/> object</returns> 56public Encoding GetEncoding() => Provider?.GetEncoding(CodePage) ?? Encoding.GetEncoding(CodePage);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\EncodingProvider.cs (16)

src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\EncodingTable.cs (3)

113if (codePage == Encoding.CodePageUTF7 && !LocalAppContextSwitches.EnableUnsafeUTF7Encoding) 145if (codePage != Encoding.CodePageUTF7 || LocalAppContextSwitches.EnableUnsafeUTF7Encoding) 157encodingInfoList.Remove(Encoding.CodePageUTF7); // won't throw if doesn't exist

src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\Latin1Encoding.Sealed.cs (1)

11/// off of <see cref="Encoding.Latin1"/>.

src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\TranscodingStream.cs (4)

28private readonly Encoding _innerEncoding; 29private readonly Encoding _thisEncoding; 53internal TranscodingStream(Stream innerStream, Encoding innerEncoding, Encoding thisEncoding, bool leaveOpen)

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

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\Reflection\Runtime\MethodInfos\CustomMethodMapper.String.cs (2)

77map.AddConstructor(type, new Type[] { typeof(sbyte*), typeof(int), typeof(int), typeof(Encoding) }, 80return new string((sbyte*)(IntPtr)(args[0]), (int)(args[1]), (int)(args[2]), (Encoding)(args[3]));

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

13void SetInput(byte[] buffer, int offset, int count, Encoding? encoding, XmlDictionaryReaderQuotas quotas, 16void SetInput(Stream stream, Encoding? encoding, XmlDictionaryReaderQuotas quotas,

System\Runtime\Serialization\Json\IXmlJsonWriterInitializer.cs (1)

12void SetOutput(Stream stream, Encoding encoding, bool ownsStream);

System\Runtime\Serialization\Json\JsonEncodingStreamWrapper.cs (8)

25private Encoding? _encoding; 32public JsonEncodingStreamWrapper(Stream stream, Encoding? encoding, bool isReader) 120public static ArraySegment<byte> ProcessBuffer(byte[] buffer, int offset, int count, Encoding? encoding) 195_byteCount = Encoding.UTF8.GetBytes(_chars, 0, charCount, _bytes, 0); 278private static Encoding GetEncoding(SupportedEncoding e) => 296private static SupportedEncoding GetSupportedEncoding(Encoding? encoding) 449private void InitForReading(Stream inputStream, Encoding? expectedEncoding) 482private void InitForWriting(Stream outputStream, Encoding writeEncoding)

System\Runtime\Serialization\Json\JsonReaderWriterFactory.cs (7)

29public static XmlDictionaryReader CreateJsonReader(Stream stream, Encoding? encoding, XmlDictionaryReaderQuotas quotas, OnXmlDictionaryReaderClose? onClose) 41public static XmlDictionaryReader CreateJsonReader(byte[] buffer, int offset, int count, Encoding? encoding, XmlDictionaryReaderQuotas quotas, OnXmlDictionaryReaderClose? onClose) 50return CreateJsonWriter(stream, Encoding.UTF8, true); 53public static XmlDictionaryWriter CreateJsonWriter(Stream stream, Encoding encoding) 58public static XmlDictionaryWriter CreateJsonWriter(Stream stream, Encoding encoding, bool ownsStream) 63public static XmlDictionaryWriter CreateJsonWriter(Stream stream, Encoding encoding, bool ownsStream, bool indent) 68public static XmlDictionaryWriter CreateJsonWriter(Stream stream, Encoding encoding, bool ownsStream, bool indent, string? indentChars)

System\Runtime\Serialization\Json\JsonXmlDataContract.cs (1)

33StringStream stream = new(xmlContent, Encoding.UTF8);

System\Runtime\Serialization\Json\XmlJsonReader.cs (10)

System\Runtime\Serialization\Json\XmlJsonWriter.cs (2)

236public void SetOutput(Stream stream, Encoding encoding, bool ownsStream) 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 (9)

40private Encoding? _encoding; 54public EncodingStreamWrapper(Stream stream, Encoding? encoding) 123private static Encoding GetEncoding(SupportedEncoding e) => 132private static Encoding GetSafeEncoding(SupportedEncoding e) => 150private static SupportedEncoding GetSupportedEncoding(Encoding? encoding) 165public EncodingStreamWrapper(Stream stream, Encoding encoding, bool emitBOM) 432internal static ArraySegment<byte> ProcessBuffer(byte[] buffer, int offset, int count, Encoding? encoding) 453Encoding localEnc; 612_byteCount = Encoding.UTF8.GetBytes(_chars, 0, charCount, _bytes, 0);

System\Xml\XmlBaseReader.cs (1)

1418private int ReadBytes(Encoding encoding, int byteBlock, int charBlock, byte[] buffer, int offset, int byteCount, bool readContent)

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

700public void SetOutput(Stream stream, Encoding encoding, bool ownsStream)

System\Xml\XmlDictionaryReader.cs (12)

System\Xml\XmlDictionaryString.cs (1)

78return _buffer ??= System.Text.Encoding.UTF8.GetBytes(_value);

System\Xml\XmlDictionaryWriter.cs (4)

47public static XmlDictionaryWriter CreateTextWriter(Stream stream, Encoding encoding) 52public static XmlDictionaryWriter CreateTextWriter(Stream stream, Encoding encoding, bool ownsStream) 60public static XmlDictionaryWriter CreateMtomWriter(Stream stream, Encoding encoding, int maxSizeInBytes, string startInfo) 65public static XmlDictionaryWriter CreateMtomWriter(Stream stream, Encoding encoding, int maxSizeInBytes, string startInfo, string? boundary, string? startUri, bool writeMessageHeaders, bool ownsStream)

System\Xml\XmlNodeWriter.cs (8)

System\Xml\XmlStreamNodeWriter.cs (2)

22private Encoding? _encoding; 30protected void SetOutput(Stream stream, bool ownsStream, Encoding? encoding)

System\Xml\XmlUTF8TextReader.cs (6)

20void SetInput(byte[] buffer, int offset, int count, Encoding? encoding, XmlDictionaryReaderQuotas quotas, OnXmlDictionaryReaderClose? onClose); 21void SetInput(Stream stream, Encoding? encoding, XmlDictionaryReaderQuotas quotas, OnXmlDictionaryReaderClose? onClose); 556public void SetInput(byte[] buffer, int offset, int count, Encoding? encoding, XmlDictionaryReaderQuotas quotas, OnXmlDictionaryReaderClose? onClose) 572public void SetInput(Stream stream, Encoding? encoding, XmlDictionaryReaderQuotas quotas, OnXmlDictionaryReaderClose? onClose) 646XmlExceptionHelper.ThrowTokenExpected(this, "?>", Encoding.UTF8.GetString(buffer, offset, 2)); 1061XmlExceptionHelper.ThrowTokenExpected(this, "[CDATA[", Encoding.UTF8.GetString(buffer, offset, 7));

System\Xml\XmlUTF8TextWriter.cs (9)

13void SetOutput(Stream stream, Encoding encoding, bool ownsStream); 20public void SetOutput(Stream stream, Encoding encoding, bool ownsStream) 25if (encoding.WebName != Encoding.UTF8.WebName) 58private Encoding? _encoding; 90public new void SetOutput(Stream stream, bool ownsStream, Encoding? encoding) 92Encoding? utf8Encoding = null; 93if (encoding != null && encoding.CodePage == Encoding.UTF8.CodePage) 103public Encoding? Encoding 131if (_encoding.WebName == Encoding.BigEndianUnicode.WebName)

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

_generated\190\Windows.Win32.PCSTR.g.cs (1)

69 public override string ToString() => this.Value is null ? null : new string((sbyte*)this.Value, 0, this.Length, global::System.Text.Encoding.Default);

_generated\202\Windows.Win32.PInvokeCore.KERNEL32.dll.g.cs (3)

253 fixed (byte* lpMultiByteStrLocal = lpMultiByteStr is object ? global::System.Text.Encoding.Default.GetBytes(lpMultiByteStr) : null) 303 fixed (byte* lpDefaultCharLocal = lpDefaultChar is object ? global::System.Text.Encoding.Default.GetBytes(lpDefaultChar) : null) 318 fixed (byte* lpDefaultCharLocal = lpDefaultChar is object ? global::System.Text.Encoding.Default.GetBytes(lpDefaultChar) : null)

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

118DataFormatNames.Rtf => ReadRegisteredFormatStringFromHGLOBAL(hglobal, Encoding.Default), 241private static unsafe string ReadRegisteredFormatStringFromHGLOBAL(HGLOBAL hglobal, Encoding encoding) 301return Encoding.UTF8.GetString(bytes);

System\Xml\BinaryXml\XmlBinaryReader.cs (6)

3981Encoding enc = System.Text.Encoding.GetEncoding(codepage); 4128Encoding enc = System.Text.Encoding.GetEncoding(codepage); 4305Encoding enc = System.Text.Encoding.GetEncoding(codepage);

System\Xml\Core\XmlEncodedRawTextWriter.cs (2)

33protected Encoding? _encoding; 163_encoding = (Encoding)settings.Encoding.Clone();

System\Xml\Core\XmlParserContext.cs (4)

23private Encoding? _encoding; 31public XmlParserContext(XmlNameTable? nt, XmlNamespaceManager? nsMgr, string? xmlLang, XmlSpace xmlSpace, Encoding? enc) 47string? xmlLang, XmlSpace xmlSpace, Encoding? enc) 195public Encoding? Encoding

System\Xml\Core\XmlTextReader.cs (1)

377public Encoding? Encoding

System\Xml\Core\XmlTextReaderImpl.cs (31)

214private Encoding? _reportedEncoding; 508Encoding? enc = context?.Encoding; 535InitStringInput(string.Empty, Encoding.Unicode, xmlFragment); 540InitStringInput(context.BaseURI, Encoding.Unicode, xmlFragment); 555InitStringInput((context == null) ? string.Empty : context.BaseURI, Encoding.Unicode, $"<?xml {xmlFragment}?>"); 651Encoding? enc = null; 728Encoding? enc = null; 813InitStringInput(string.Empty, Encoding.Unicode, xmlFragment); 2028internal Encoding? Encoding 2620InitStringInput(baseUri, Encoding.Unicode, internalDtd); 2818private void InitStreamInput(Stream stream, Encoding? encoding) 2823private void InitStreamInput(string baseUriStr, Stream stream, Encoding? encoding) 2829private void InitStreamInput(Uri? baseUri, Stream stream, Encoding? encoding) 2835private void InitStreamInput(Uri? baseUri, string baseUriStr, Stream stream, Encoding? encoding) 2840private void InitStreamInput(Uri? baseUri, string baseUriStr, Stream stream, byte[]? bytes, int byteCount, Encoding? encoding) 2936_ps.encoding = Encoding.Unicode; 2944private void InitStringInput(string baseUriStr, Encoding? originalEncoding, string str) 3087private Encoding? DetectEncoding() 3123return Encoding.BigEndianUnicode; 3132return Encoding.Unicode; 3141return Encoding.Unicode; 3150return Encoding.BigEndianUnicode; 3172private void SetupEncoding(Encoding? encoding) 3177_ps.encoding = Encoding.UTF8; 3204private void SwitchEncoding(Encoding newEncoding) 3219private Encoding CheckEncoding(string newEncodingName) 3250Encoding? newEncoding = null; 3259newEncoding = Encoding.GetEncoding(newEncodingName); 3631Encoding? encoding = null; 8028Encoding? enc = _ps.encoding; 8045Encoding? enc = _ps.encoding;

System\Xml\Core\XmlTextReaderImplAsync.cs (8)

84Encoding? enc = null; 116Encoding? enc = null; 860private Task InitStreamInputAsync(Uri baseUri, Stream stream, Encoding? encoding) 866private async Task InitStreamInputAsync(Uri? baseUri, string baseUriStr, Stream stream, byte[]? bytes, int byteCount, Encoding? encoding) 967_ps.encoding = Encoding.Unicode; 999private Task SwitchEncodingAsync(Encoding newEncoding) 1198Encoding? encoding = null; 5225Encoding? enc = _ps.encoding;

System\Xml\Core\XmlTextReaderImplHelpers.cs (1)

31internal Encoding? encoding;

System\Xml\Core\XmlTextWriter.cs (3)

135private readonly Encoding? _encoding; 280public XmlTextWriter(Stream w, Encoding? encoding) : this() 292public XmlTextWriter(string filename, Encoding? encoding)

System\Xml\Core\XmlUtf8RawTextWriter.cs (1)

35protected Encoding _encoding = null!;

System\Xml\Core\XmlValidatingReader.cs (1)

333public Encoding? Encoding

System\Xml\Core\XmlValidatingReaderImpl.cs (1)

440internal Encoding? Encoding

System\Xml\Core\XmlWriterSettings.cs (6)

45private Encoding _encoding; 78public Encoding Encoding 367Debug.Assert(Encoding.UTF8.WebName == "utf-8"); 503_encoding = Encoding.UTF8; 603Debug.Assert(Encoding.Equals(Encoding.GetEncoding(Encoding.CodePage)), "Cannot serialize encoding correctly"); 654Encoding = Encoding.GetEncoding(reader.ReadInt32());

System\Xml\Dom\XmlDocument.cs (2)

1346internal Encoding? TextEncoding 1355return System.Text.Encoding.GetEncoding(value);

System\Xml\Dom\XmlDomTextWriter.cs (2)

14public XmlDOMTextWriter(Stream w, Encoding? encoding) : base(w, encoding) 18public XmlDOMTextWriter(string filename, Encoding? encoding) : base(filename, encoding)

System\Xml\Resolvers\XmlPreloadedResolver.cs (1)

106return new MemoryStream(Encoding.Unicode.GetBytes(_str));

System\Xml\Serialization\Compiler.cs (1)

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

System\Xml\XmlEncoding.cs (4)

285internal static Encoding UCS4_Littleendian 293internal static Encoding UCS4_Bigendian 301internal static Encoding UCS4_2143 309internal static Encoding UCS4_3412

System\Xml\Xsl\Xslt\XsltLoader.cs (2)

663Encoding encoding = Encoding.GetEncoding(_input.Value);

System\Xml\Xsl\XsltOld\SequentialOutput.cs (3)

58protected Encoding? encoding; 75private Encoding? _utf8Encoding; 609_utf8Encoding = Encoding.UTF8;

System\Xml\Xsl\XsltOld\XsltOutput.cs (4)

26private Encoding _encoding = System.Text.Encoding.UTF8; 84internal Encoding Encoding 142_encoding = System.Text.Encoding.GetEncoding(value);

System\Xml\Linq\XDocument.cs (4)

8using Encoding = System.Text.Encoding; 604ws.Encoding = Encoding.GetEncoding(_declaration.Encoding); 637ws.Encoding = Encoding.GetEncoding(_declaration.Encoding); 781ws.Encoding = Encoding.GetEncoding(_declaration.Encoding);

System\Reflection\Emit\CustomAttributeWrapper.cs (1)

97return Text.Encoding.UTF8.GetString(data.Slice(pos, len));

System\Reflection\Internal\Utilities\MemoryBlock.cs (2)

275return Encoding.Unicode.GetString(ptr, byteCount); 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 (3)

29public Encoding Encoding { get; } 35public static MetadataStringDecoder DefaultUTF8 { get; } = new MetadataStringDecoder(Encoding.UTF8); 44public MetadataStringDecoder(Encoding encoding)

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

248BinaryWriter bw = new BinaryWriter(_output, Encoding.UTF8); 297BinaryWriter names = new BinaryWriter(nameSection, Encoding.Unicode); 303BinaryWriter data = new BinaryWriter(dataSection, Encoding.UTF8);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Resources\ResourceReader.cs (3)

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); 439return Encoding.Unicode.GetString(bytes, 0, byteLen);

src\runtime\src\libraries\Common\src\System\Resources\ResourceWriter.cs (3)

248BinaryWriter bw = new BinaryWriter(_output, Encoding.UTF8); 297BinaryWriter names = new BinaryWriter(nameSection, Encoding.Unicode); 303BinaryWriter data = new BinaryWriter(dataSection, Encoding.UTF8);

src\runtime\artifacts\obj\System.Runtime\Release\net11.0\System.Runtime.Forwards.cs (1)

816[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Text.Encoding))]

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\Internal\Cryptography\PkcsHelpers.cs (2)

144Encoding.Unicode.GetBytes(s, 0, s.Length, octets, 0); 166string s = Encoding.Unicode.GetString(octets, 0, end);

src\runtime\src\libraries\Common\src\System\Security\Cryptography\PasswordBasedEncryption.cs (6)

202System.Text.Encoding? encoding = null; 210encoding = System.Text.Encoding.UTF8; 357System.Text.Encoding encoding = System.Text.Encoding.UTF8; 487System.Text.Encoding? encoding = null; 495encoding = System.Text.Encoding.UTF8;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Pkcs12Kdf.cs (2)

272Encoding bigEndianUnicode = System.Text.Encoding.BigEndianUnicode;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\PqcBlobHelpers.cs (1)

338Encoding.Unicode.GetBytes(parameterSet, buffer.Slice(blobHeaderSize));

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Utf8DataEncoding.cs (1)

10internal static Encoding ThrowingUtf8Encoding { get; } = new UTF8Encoding(false, true);

System\Security\Cryptography\BasicSymmetricCipherLiteNCrypt.cs (3)

19new CngProperty(KeyPropertyName.ChainingMode, Encoding.Unicode.GetBytes(Cng.BCRYPT_CHAIN_MODE_ECB + "\0"), CngPropertyOptions.None); 21new CngProperty(KeyPropertyName.ChainingMode, Encoding.Unicode.GetBytes(Cng.BCRYPT_CHAIN_MODE_CBC + "\0"), CngPropertyOptions.None); 23new CngProperty(KeyPropertyName.ChainingMode, Encoding.Unicode.GetBytes(Cng.BCRYPT_CHAIN_MODE_CFB + "\0"), CngPropertyOptions.None);

System\Security\Cryptography\CapiHelper.Windows.cs (1)

431retStr = Encoding.ASCII.GetString(pb, 0, cb - 1);

System\Security\Cryptography\CngHelpers.cs (1)

73using (BinaryReader br = new BinaryReader(ms, Encoding.Unicode))

System\Security\Cryptography\CngKey.EC.cs (1)

74System.Text.Encoding.Unicode.GetBytes(curveName, 0, curveName.Length, curveNameBytes, 0);

System\Security\Cryptography\Rfc2898DeriveBytes.cs (2)

59Encoding.UTF8.GetBytes(password ?? throw new ArgumentNullException(nameof(password))), 89byte[] passwordBytes = Encoding.UTF8.GetBytes(password);

System\Security\Cryptography\Rfc2898DeriveBytes.OneShot.cs (3)

156/// other encodings, convert the password string to bytes using the appropriate <see cref="System.Text.Encoding" /> 199/// other encodings, convert the password string to bytes using the appropriate <see cref="System.Text.Encoding" /> 244/// other encodings, convert the password string to bytes using the appropriate <see cref="System.Text.Encoding" />

System\Security\Cryptography\X509Certificates\WindowsHelpers.cs (1)

60int bytesWritten = Encoding.ASCII.GetBytes(oidString, new Span<byte>(pOidContents, oidString.Length));

Internal\Cryptography\Pal\Windows\HeapBlockRetainer.cs (2)

46int length = Encoding.ASCII.GetByteCount(s); 52Encoding.ASCII.GetBytes(s, ascii);

Internal\Cryptography\Pal\Windows\HelpersWindows.cs (1)

117string oidValue = Encoding.ASCII.GetString(oidBytes, 0, length);

src\runtime\src\libraries\Common\src\Internal\Cryptography\PkcsHelpers.cs (2)

144Encoding.Unicode.GetBytes(s, 0, s.Length, octets, 0); 166string s = Encoding.Unicode.GetString(octets, 0, end);

src\runtime\src\libraries\Common\src\System\Security\Cryptography\PasswordBasedEncryption.cs (6)

202System.Text.Encoding? encoding = null; 210encoding = System.Text.Encoding.UTF8; 357System.Text.Encoding encoding = System.Text.Encoding.UTF8; 487System.Text.Encoding? encoding = null; 495encoding = System.Text.Encoding.UTF8;

src\runtime\src\libraries\Common\src\System\Security\Cryptography\Pkcs12Kdf.cs (2)

272Encoding bigEndianUnicode = System.Text.Encoding.BigEndianUnicode;

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

71private Encoding _encoding; 114_encoding = Encoding.UTF8; 179public Encoding Encoding

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\Security\Principal\WindowsIdentity.cs (2)

154byte[] upnBytes = Encoding.Unicode.GetBytes(sUserPrincipalName); 246byte[] asciiPackageName = Encoding.ASCII.GetBytes(packageName);

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

41public static Encoding TextEncoding

System\ServiceModel\HttpBindingBase.cs (1)

159public Encoding TextEncoding

System\ServiceModel\WSHttpBindingBase.cs (1)

131public Text.Encoding TextEncoding

ServiceModel\BasicHttpBindingTest.cs (12)

26Assert.Equal<Encoding>(Encoding.GetEncoding("utf-8"), binding.TextEncoding); 27Assert.Equal(Encoding.GetEncoding("utf-8").WebName, binding.TextEncoding.WebName); 51Assert.Equal<Encoding>(Encoding.GetEncoding("utf-8"), binding.TextEncoding); 52Assert.Equal(Encoding.GetEncoding("utf-8").WebName, binding.TextEncoding.WebName); 75Assert.Equal<Encoding>(Encoding.GetEncoding("utf-8"), binding.TextEncoding); 76Assert.Equal(Encoding.GetEncoding("utf-8").WebName, binding.TextEncoding.WebName); 290public static void TextEncoding_Property_Sets(Encoding encoding) 294Assert.Equal<Encoding>(encoding, binding.TextEncoding); 299public static void TextEncoding_Property_Set_Invalid_Value_Throws(Encoding encoding)

ServiceModel\BasicHttpsBindingTest.cs (9)

24Assert.Equal<Encoding>(Encoding.GetEncoding("utf-8"), binding.TextEncoding); 25Assert.Equal(Encoding.GetEncoding("utf-8").WebName, binding.TextEncoding.WebName); 49Assert.Equal<Encoding>(Encoding.GetEncoding("utf-8"), binding.TextEncoding); 50Assert.Equal(Encoding.GetEncoding("utf-8").WebName, binding.TextEncoding.WebName); 280public static void TextEncoding_Property_Sets(Encoding encoding) 284Assert.Equal<Encoding>(encoding, binding.TextEncoding); 289public static void TextEncoding_Property_Set_Invalid_Value_Throws(Encoding encoding)

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

15private static Encoding s_asciiEncoding; 17private static Encoding AsciiEncoding 23s_asciiEncoding = Encoding.GetEncoding("ascii"); 32return ParseQueryString(query, Encoding.UTF8); 35public static NameValueCollection ParseQueryString(string query, Encoding encoding) 61return UrlEncode(str, Encoding.UTF8); 80return UrlEncodeSpaces(UrlEncodeNonAscii(str, Encoding.UTF8)); 83public static string UrlEncode(string str, Encoding encoding) 144private static string UrlEncodeNonAscii(string str, Encoding e) 152e = Encoding.UTF8; 170public static byte[] UrlEncodeToBytes(string str, Encoding e) 180public static string UrlDecode(string str, Encoding e) 292private static string UrlDecodeStringFromStringInternal(string s, Encoding e) 420private Encoding _encoding; 431internal UrlDecoder(int bufferSize, Encoding encoding) 490internal HttpValueCollection(string str, Encoding encoding) 501internal void FillFromString(string s, bool urlencoded, Encoding encoding)

Internals\System\Xml\XmlMtomReader.cs (24)

Internals\System\Xml\XmlMtomWriter.cs (12)

21void SetOutput(Stream stream, Encoding encoding, int maxSizeInBytes, string startInfo, string boundary, string startUri, bool writeMessageHeaders, bool ownsStream); 26public static XmlDictionaryWriter Create(Stream stream, Encoding encoding, int maxSizeInBytes, string startInfo) 31public static XmlDictionaryWriter Create(Stream stream, Encoding encoding, int maxSizeInBytes, string startInfo, string boundary, string startUri, bool writeMessageHeaders, bool ownsStream) 45private Encoding _encoding; 66public void SetOutput(Stream stream, Encoding encoding, int maxSizeInBytes, string startInfo, string boundary, string startUri, bool writeMessageHeaders, bool ownsStream) 159internal static bool IsUTF8Encoding(Encoding encoding) 181private static string GetContentTypeForRootMimePart(Encoding encoding, string startInfo) 191private static string CharSet(Encoding enc) 194if (string.Compare(name, Encoding.UTF8.WebName, StringComparison.OrdinalIgnoreCase) == 0) 196if (string.Compare(name, Encoding.Unicode.WebName, StringComparison.OrdinalIgnoreCase) == 0) 198if (string.Compare(name, Encoding.BigEndianUnicode.WebName, StringComparison.OrdinalIgnoreCase) == 0) 1186Encoding.ASCII.GetBytes(boundary, 0, boundary.Length, boundaryBytes, MimeGlobals.BoundaryPrefix.Length);

System\IdentityModel\CanonicalFormWriter.cs (2)

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

22private Encoding _writeEncoding; 39public MtomMessageEncoderFactory(MessageVersion version, Encoding writeEncoding, int maxReadPoolSize, int maxWritePoolSize, int maxBufferSize, XmlDictionaryReaderQuotas quotas) 254public static Encoding[] GetSupportedEncodings() 256Encoding[] supported = TextEncoderDefaults.SupportedEncodings; 257Encoding[] enc = new Encoding[supported.Length]; 268private Encoding _writeEncoding; 280public MtomMessageEncoder(MessageVersion version, Encoding writeEncoding, int maxReadPoolSize, int maxWritePoolSize, int maxBufferSize, XmlDictionaryReaderQuotas quotas, MtomMessageEncoderFactory factory) 353Encoding tmp;

System\ServiceModel\Channels\MtomMessageEncodingBindingElement.cs (3)

17private Encoding _writeEncoding; 22public MtomMessageEncodingBindingElement(MessageVersion messageVersion, Encoding writeEncoding) 117public Encoding WriteEncoding

System\ServiceModel\Channels\TextMessageEncoder.cs (18)

29public TextMessageEncoderFactory(MessageVersion version, Encoding writeEncoding, int maxReadPoolSize, int maxWritePoolSize, XmlDictionaryReaderQuotas quotas) 54public static Encoding[] GetSupportedEncodings() 56Encoding[] supported = TextEncoderDefaults.SupportedEncodings; 57Encoding[] enc = new Encoding[supported.Length]; 93internal static string GetContentType(string mediaType, Encoding encoding) 100Encoding[] readEncodings = TextMessageEncoderFactory.GetSupportedEncodings(); 113internal static Encoding GetEncodingFromContentType(string contentType, ContentEncoding[] contentMap) 185Encoding enc; 232internal static bool TryGetEncodingFromCharSet(string charSet, out Encoding encoding) 246internal Encoding encoding; 259private Encoding _writeEncoding; 266public TextMessageEncoder(MessageVersion version, Encoding writeEncoding, int maxReadPoolSize, int maxWritePoolSize, XmlDictionaryReaderQuotas quotas) 310private static bool IsUTF8Encoding(Encoding encoding) 344Encoding tmp; 653private XmlReader TakeStreamedReader(Stream stream, Encoding enc) 719private Encoding _encoding; 729internal Encoding Encoding

System\ServiceModel\Channels\TextMessageEncodingBindingElement.cs (3)

18private Encoding _writeEncoding; 25public TextMessageEncodingBindingElement(MessageVersion messageVersion, Encoding writeEncoding) 118public Encoding WriteEncoding

System\ServiceModel\Channels\TransportDefaults.cs (17)

48public static readonly Encoding Encoding = Encoding.GetEncoding(TextEncoderDefaults.EncodingString); 50public static readonly Encoding[] SupportedEncodings = new Encoding[] { Encoding.UTF8, Encoding.Unicode, Encoding.BigEndianUnicode }; 55new CharSetEncoding("utf-8", Encoding.UTF8), 56new CharSetEncoding("utf-16LE", Encoding.Unicode), 57new CharSetEncoding("utf-16BE", Encoding.BigEndianUnicode), 62public static void ValidateEncoding(Encoding encoding) 65Encoding[] supportedEncodings = SupportedEncodings; 76public static string EncodingToCharSet(Encoding encoding) 82Encoding enc = charSetEncodings[i].Encoding; 96public static bool TryGetEncoding(string charSet, out Encoding encoding) 133public Encoding Encoding; 135public CharSetEncoding(string charSet, Encoding enc)

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

System\ServiceModel\Security\WSUtilitySpecificationVersion.cs (1)

162Encoding encoding = CanonicalFormWriter.Utf8WithoutPreamble;

Channels\TextMessageEncodingBindingElementTest.cs (5)

20Assert.Equal<Encoding>(Encoding.UTF8, element.WriteEncoding); 25public static void WriteEncoding_Property_Sets(Encoding encoding) 29Assert.Equal<Encoding>(encoding, element.WriteEncoding); 34public static void WriteEncoding_Property_Set_Throws_For_Invalid_Encodings(Encoding encoding)

ServiceModel\ChannelFactoryTest.cs (1)

28new TextMessageEncodingBindingElement(MessageVersion.Default, Encoding.UTF8),

Internal\AlphabetConverter.cs (1)

248using (BinaryReader reader = new(input, System.Text.Encoding.Unicode))

Internal\StreamMarshaler.cs (1)

80BinaryReader br = new(_stream, Encoding.Unicode);

System.Text.Encoding.cs (1)

16[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Text.Encoding))]

System\Text\CodePagesEncodingProvider.cs (8)

14private readonly Dictionary<int, Encoding> _encodings = new Dictionary<int, Encoding>(); 24public override Encoding? GetEncoding(int codepage) 39Encoding? result = null; 67if (_encodings.TryGetValue(codepage, out Encoding? cachedEncoding)) 85public override Encoding? GetEncoding(string name) 133private static Encoding? GetEncodingRare(int codepage) 135Encoding? result = null;

System\Text\EncoderNLS.cs (1)

210public Encoding Encoding

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

src\runtime\src\libraries\Common\src\Polyfills\EncodingPolyfills.cs (7)

13public static unsafe int GetByteCount(this Encoding encoding, ReadOnlySpan<char> chars) 21public static unsafe int GetCharCount(this Encoding encoding, ReadOnlySpan<byte> bytes) 29public static int GetBytes(this Encoding encoding, string str, Span<byte> bytes) 34public static unsafe int GetBytes(this Encoding encoding, ReadOnlySpan<char> chars, Span<byte> bytes) 43public static unsafe int GetChars(this Encoding encoding, ReadOnlySpan<byte> bytes, Span<char> chars) 52public static unsafe string GetString(this Encoding encoding, ReadOnlySpan<byte> bytes) 60public static bool TryGetChars(this Encoding encoding, ReadOnlySpan<byte> bytes, Span<char> chars, out int charsWritten)

System\Transactions\DtcProxyShim\Xactopt.cs (2)

49Encoding.ASCII.TryGetBytes(managed.SzDescription, native.SzDescription, out _); 55=> new(unmanaged.UlTimeout, Encoding.ASCII.GetString(unmanaged.SzDescription));

System\Web\HttpUtility.cs (17)

81public static NameValueCollection ParseQueryString(string query) => ParseQueryString(query, Encoding.UTF8); 83public static NameValueCollection ParseQueryString(string query, Encoding encoding) 161public static string? UrlEncode(string? str) => UrlEncode(str, Encoding.UTF8); 167public static string? UrlEncode(string? str, Encoding e) => 168str == null ? null : Encoding.ASCII.GetString(UrlEncodeToBytes(str, e)); 171public static string? UrlEncode(byte[]? bytes) => bytes == null ? null : Encoding.ASCII.GetString(UrlEncodeToBytes(bytes)); 174public static string? UrlEncode(byte[]? bytes, int offset, int count) => bytes == null ? null : Encoding.ASCII.GetString(UrlEncodeToBytes(bytes, offset, count)); 177public static byte[]? UrlEncodeToBytes(string? str) => UrlEncodeToBytes(str, Encoding.UTF8); 184public static byte[]? UrlEncodeUnicodeToBytes(string? str) => str == null ? null : Encoding.ASCII.GetBytes(UrlEncodeUnicode(str)); 187public static string? UrlDecode(string? str) => UrlDecode(str, Encoding.UTF8); 190public static string? UrlDecode(byte[]? bytes, Encoding e) => bytes == null ? null : UrlDecode(bytes, 0, bytes.Length, e); 193public static byte[]? UrlDecodeToBytes(string? str) => UrlDecodeToBytes(str, Encoding.UTF8); 196public static unsafe byte[]? UrlDecodeToBytes(string? str, Encoding e) 219public static byte[]? UrlEncodeToBytes(string? str, Encoding e) => str == null ? null : HttpEncoder.UrlEncode(str, e); 229public static string? UrlDecode(string? str, Encoding e) => HttpEncoder.UrlDecode(str, e); 231private static string UrlDecode(ReadOnlySpan<char> str, Encoding e) => HttpEncoder.UrlDecode(str, e); 234public static string? UrlDecode(byte[]? bytes, int offset, int count, Encoding e) =>

System\Web\Util\HttpEncoder.cs (8)

242internal static string? UrlDecode(byte[]? bytes, int offset, int count, Encoding encoding) 307internal static string? UrlDecode(string? value, Encoding encoding) 317internal static string UrlDecode(ReadOnlySpan<char> value, Encoding encoding) 460internal static unsafe byte[] UrlEncode(string str, Encoding e) 570byte[] bytes = ArrayPool<byte>.Shared.Rent(Encoding.UTF8.GetMaxByteCount(toEncode.Length)); 571int utf8Length = Encoding.UTF8.GetBytes(toEncode, bytes); 627private readonly Encoding _encoding; 639internal UrlDecoder(Span<char> charBuffer, Span<byte> byteBuffer, Encoding encoding)

System\Resources\ResXDataNode.cs (2)

180: new ResXFileRef(FileRefFullPath, FileRefType!, Encoding.GetEncoding(FileRefTextEncoding)); 613? new ResXFileRef(FileRefFullPath, FileRefType, Encoding.GetEncoding(FileRefTextEncoding))

System\Resources\ResxFileRef.Converter.cs (3)

111Encoding textFileEncoding = parts.Length > 2 ? Encoding.GetEncoding(parts[2]) : Encoding.Default;

System\Resources\ResXFileRef.cs (2)

34public ResXFileRef(string fileName, string typeName, Encoding textFileEncoding) : this(fileName, typeName) 46public Encoding? TextFileEncoding { get; }

System\Resources\ResXResourceWriter.cs (2)

161_xmlTextWriter = new XmlTextWriter(_stream, Encoding.UTF8); 166_xmlTextWriter = new XmlTextWriter(_fileName, Encoding.UTF8);

System\Windows\Forms\Control.cs (3)

19using Encoding = System.Text.Encoding; 6815bytes = Encoding.Unicode.GetBytes(value); 6816nullBytes = Encoding.Unicode.GetBytes(nullChar);

System\Windows\Forms\Controls\DataGridView\DataGridView.Methods.cs (8)

8152byte[] sourceBytes = Encoding.Unicode.GetBytes(sbContent.ToString()); 8153byte[] destinationBytes = Encoding.Convert(Encoding.Unicode, Encoding.UTF8, sourceBytes); 8176sourceBytes = Encoding.Unicode.GetBytes(sbContent.ToString()); 8177destinationBytes = Encoding.Convert(Encoding.Unicode, Encoding.UTF8, sourceBytes);

System\Windows\Forms\Controls\RichTextBox\RichTextBox.cs (5)

2915encodedBytes = Encoding.Unicode.GetBytes(str); 2920encodedBytes = (CodePagesEncodingProvider.Instance.GetEncoding(0) ?? Encoding.UTF8).GetBytes(str); 2964string str = (CodePagesEncodingProvider.Instance.GetEncoding(0) ?? Encoding.UTF8).GetString(bytes); 3047result = Encoding.Unicode.GetString(bytes, 0, bytes.Length); 3052result = (CodePagesEncodingProvider.Instance.GetEncoding(0) ?? Encoding.UTF8).GetString(bytes, 0, bytes.Length);

System\Windows\Forms\Controls\TextBox\TextBoxBase.cs (4)

2280Encoding e = Encoding.Default; 2329Encoding e = Encoding.Default;

System\Windows\Forms\Controls\WebBrowser\WebBrowser.cs (1)

325StreamWriter sw = new(ms, Encoding.UTF8);

System\ComponentModel\Design\BinaryEditor.cs (1)

62Encoding.Unicode.GetBytes(stringValue.AsSpan(), buffer.AsSpan());

System\ComponentModel\Design\ByteViewer.cs (2)

343Encoding.Unicode.GetChars(_dataBuf.AsSpan(i, 2), new Span<char>(ref unicodeChar)); 425Encoding.Unicode.GetChars(dataBuf.AsSpan(), text);

System\Windows\Forms\Design\Behavior\BehaviorService.cs (2)

776bytes = Encoding.Unicode.GetBytes(text); 777nullBytes = Encoding.Unicode.GetBytes(nullChar);

System\Windows\Forms\Design\DocumentDesigner.cs (1)

281string clsid = Text.Encoding.Default.GetString(bytes);

_generated\236\Windows.Win32.IRichEditOle.g.cs (3)

252 fixed (byte* lpstrUserTypeNewLocal = lpstrUserTypeNew is object ? global::System.Text.Encoding.Default.GetBytes(lpstrUserTypeNew) : null) 362 fixed (byte* lpstrContainerObjLocal = lpstrContainerObj is object ? global::System.Text.Encoding.Default.GetBytes(lpstrContainerObj) : null) 364 fixed (byte* lpstrContainerAppLocal = lpstrContainerApp is object ? global::System.Text.Encoding.Default.GetBytes(lpstrContainerApp) : null)

_generated\418\Windows.Win32.PInvoke.KERNEL32.dll.g.cs (1)

511 fixed (byte* lpProcNameLocal = lpProcName is object ? global::System.Text.Encoding.Default.GetBytes(lpProcName) : null)

_generated\593\Windows.Win32.UI_Controls_RichEdit_IRichEditOle_Extensions.g.cs (3)

46 fixed (byte* lpstrUserTypeNewLocal = lpstrUserTypeNew is object ? global::System.Text.Encoding.Default.GetBytes(lpstrUserTypeNew) : null) 72 fixed (byte* lpstrContainerObjLocal = lpstrContainerObj is object ? global::System.Text.Encoding.Default.GetBytes(lpstrContainerObj) : null) 74 fixed (byte* lpstrContainerAppLocal = lpstrContainerApp is object ? global::System.Text.Encoding.Default.GetBytes(lpstrContainerApp) : null)

src\wpf\src\Microsoft.DotNet.Wpf\src\Shared\System\Windows\Markup\XmlCompatibilityReader.cs (1)

728internal System.Text.Encoding Encoding

src\wpf\src\Microsoft.DotNet.Wpf\src\Shared\MS\Win32\NativeMethodsCLR.cs (2)

2348string result = Encoding.Default.GetString(buffer, offset, i - offset); 2366byte[] bytes = Encoding.Default.GetBytes(s);

TestData.cs (10)

42public static MemberDataSet<Encoding> ValidEncodings 46return new MemberDataSet<Encoding> 48{ Encoding.BigEndianUnicode }, 49{ Encoding.Unicode }, 50{ Encoding.UTF8 }, 55public static MemberDataSet<Encoding> InvalidEncodings 59MemberDataSet<Encoding> data = new MemberDataSet<Encoding>(); 64Encoding encoding = Encoding.GetEncoding(encodingName);

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

105System.Text.Encoding.RegisterProvider(System.Text.CodePagesEncodingProvider.Instance);

src\roslyn\src\Compilers\Shared\BuildProtocol.cs (4)

138using var reader = new BinaryReader(inStream, Encoding.Unicode, leaveOpen: true); 163using var writer = new BinaryWriter(memoryStream, Encoding.Unicode); 286using (var writer = new BinaryWriter(memoryStream, Encoding.Unicode)) 334using (var reader = new BinaryReader(new MemoryStream(responseBuffer), Encoding.Unicode))

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\Shared\ConsoleUtil.cs (2)

14private static readonly Encoding s_utf8Encoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false); 22Encoding savedEncoding = Console.OutputEncoding;

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

105System.Text.Encoding.RegisterProvider(System.Text.CodePagesEncodingProvider.Instance);

src\roslyn\src\Compilers\Shared\BuildProtocol.cs (4)

138using var reader = new BinaryReader(inStream, Encoding.Unicode, leaveOpen: true); 163using var writer = new BinaryWriter(memoryStream, Encoding.Unicode); 286using (var writer = new BinaryWriter(memoryStream, Encoding.Unicode)) 334using (var reader = new BinaryReader(new MemoryStream(responseBuffer), Encoding.Unicode))

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\Shared\ConsoleUtil.cs (2)

14private static readonly Encoding s_utf8Encoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false); 22Encoding savedEncoding = Console.OutputEncoding;

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;