UTF8

2768 references to UTF8

AnalyzerRunner (2)

DiagnosticAnalyzerRunner.cs (2)

228File.WriteAllText(fileName, completeOutput.ToString(), Encoding.UTF8); 229File.WriteAllText(uniqueFileName, uniqueOutput.ToString(), Encoding.UTF8);

aspire (2)

Packaging\TemporaryNuGetConfig.cs (1)

45Encoding = System.Text.Encoding.UTF8,

Program.cs (1)

213Console.OutputEncoding = Encoding.UTF8;

Aspire.Azure.Messaging.EventHubs.Tests (2)

AspireEventHubsExtensionsTests.cs (1)

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

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

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

Aspire.Azure.Security.KeyVault.Tests (2)

AspireKeyVaultExtensionsTests.cs (1)

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

MockTransport.cs (1)

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

Aspire.Cli.Tests (1)

Utils\CliTestHelper.cs (1)

321public override Encoding Encoding => Encoding.UTF8;

Aspire.Confluent.Kafka (2)

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

Aspire.Confluent.Kafka.Tests (2)

ConsumerConfigurationTests.cs (1)

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

ProducerConfigurationTests.cs (1)

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

Aspire.Dashboard (8)

Components\Dialogs\TextVisualizerDialog.razor.cs (2)

211var jsonData = Encoding.UTF8.GetBytes(jsonString); 276var formattedJson = Encoding.UTF8.GetString(stream.ToArray());

Configuration\DashboardOptions.cs (4)

49_apiKeyBytes = ApiKey != null ? Encoding.UTF8.GetBytes(ApiKey) : null; 134_primaryApiKeyBytes = PrimaryApiKey != null ? Encoding.UTF8.GetBytes(PrimaryApiKey) : null; 135_secondaryApiKeyBytes = SecondaryApiKey != null ? Encoding.UTF8.GetBytes(SecondaryApiKey) : null; 206_browserTokenBytes = BrowserToken != null ? Encoding.UTF8.GetBytes(BrowserToken) : null;

src\Shared\CompareHelpers.cs (2)

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

Aspire.Dashboard.Components.Tests (16)

Pages\TraceDetailsTests.cs (9)

76var traceId = Convert.ToHexString(Encoding.UTF8.GetBytes("1")); 131var traceId = Convert.ToHexString(Encoding.UTF8.GetBytes("1")); 147traceId = Convert.ToHexString(Encoding.UTF8.GetBytes("2")); 199var traceId = Convert.ToHexString(Encoding.UTF8.GetBytes("1")); 281var traceId = Convert.ToHexString(Encoding.UTF8.GetBytes("1")); 375var traceId = Convert.ToHexString(Encoding.UTF8.GetBytes("1")); 432var traceId = Convert.ToHexString(Encoding.UTF8.GetBytes("1")); 515var traceId = Convert.ToHexString(Encoding.UTF8.GetBytes("1")); 590var traceId = Convert.ToHexString(Encoding.UTF8.GetBytes("1"));

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

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

Aspire.Dashboard.Tests (18)

Integration\OtlpHttpServiceTests.cs (1)

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

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)

Aspire.Hosting (10)

Dashboard\ResourceServiceOptions.cs (1)

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

Dcp\DcpHost.cs (2)

330loggerCache[hashValue] = logger = _loggerFactory.CreateLogger($"Aspire.Hosting.Dcp.{Encoding.UTF8.GetString(category)}"); 333return (logger, logLevel, Encoding.UTF8.GetString(message));

Dcp\DcpKubernetesClient.cs (1)

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

DistributedApplicationBuilder.cs (2)

217var appHostNameShaBytes = SHA256.HashData(Encoding.UTF8.GetBytes(appHostName)); 222var appHostShaBytes = 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\SecretsStore.cs (1)

75File.WriteAllText(_secretsFilePath, json, Encoding.UTF8);

Utils\ImageNameGenerator.cs (1)

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

Aspire.Hosting.Azure (2)

AzureBicepResource.cs (1)

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

Provisioning\BicepUtilities.cs (1)

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

Aspire.Hosting.Azure.EventHubs (2)

AzureEventHubsExtensions.cs (2)

318Contents = Encoding.UTF8.GetString(writeStream.ToArray()), 448return Encoding.UTF8.GetString(stream.ToArray());

Aspire.Hosting.Azure.ServiceBus (2)

AzureServiceBusExtensions.cs (2)

455Contents = Encoding.UTF8.GetString(writeStream.ToArray()), 591return Encoding.UTF8.GetString(stream.ToArray());

Aspire.Hosting.Azure.Tests (14)

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)

148var headerBase64 = Convert.ToBase64String(Encoding.UTF8.GetBytes(headerJson)) 162var payloadBase64 = Convert.ToBase64String(Encoding.UTF8.GetBytes(payloadJson)) 167var signatureBase64 = Convert.ToBase64String(Encoding.UTF8.GetBytes("test-signature"))

Aspire.Hosting.GitHub.Models (1)

GitHubModelsHealthCheck.cs (1)

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

Aspire.Hosting.Kubernetes (2)

Yaml\ByteArrayStringYamlConverter.cs (2)

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

Aspire.Hosting.PostgreSQL (1)

PostgresBuilderExtensions.cs (1)

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

Aspire.Hosting.RabbitMQ.Tests (4)

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

Aspire.Hosting.Seq.Tests (1)

SeqFunctionalTests.cs (1)

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

Aspire.Hosting.Tests (11)

AspireStoreTests.cs (2)

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

Dcp\DcpExecutorTests.cs (6)

611await pipes.StandardOut.Writer.WriteAsync(Encoding.UTF8.GetBytes("2024-08-19T06:10:33.473275911Z Hello world" + Environment.NewLine)); 622await pipes.StandardErr.Writer.WriteAsync(Encoding.UTF8.GetBytes("2024-08-19T06:10:32.661Z Next" + Environment.NewLine)); 665return new MemoryStream(Encoding.UTF8.GetBytes("2024-08-19T06:10:01.000Z First" + Environment.NewLine)); 667return new MemoryStream(Encoding.UTF8.GetBytes("2024-08-19T06:10:02.000Z Second" + Environment.NewLine)); 669return new MemoryStream(Encoding.UTF8.GetBytes("2024-08-19T06:10:03.000Z Third" + Environment.NewLine)); 671return new MemoryStream(Encoding.UTF8.GetBytes(

Dcp\TestKubernetesService.cs (1)

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

ProjectResourceTests.cs (1)

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

UserSecretsParameterDefaultTests.cs (1)

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

Aspire.RabbitMQ.Client.Tests (1)

AspireRabbitMQExtensionsTests.cs (1)

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

Aspire.RabbitMQ.Client.v7.Tests (1)

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

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

AzureFunctionsEndToEnd.ApiService (2)

Program.cs (2)

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

BasicWebSite (2)

Formatters\VCardFormatter_V3.cs (1)

20SupportedEncodings.Add(Encoding.UTF8);

Formatters\VCardFormatter_V4.cs (1)

21SupportedEncodings.Add(Encoding.UTF8);

Benchmarks (2)

StartupUsingEndpointRouting.cs (1)

11private static readonly byte[] _helloWorldPayload = Encoding.UTF8.GetBytes("Hello, World!");

StartupUsingRouter.cs (1)

10private static readonly byte[] _helloWorldPayload = Encoding.UTF8.GetBytes("Hello, World!");

BinaryFormatTests (1)

FormatTests\FormattedObject\PrimitiveTypeTests.cs (1)

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

Binding.Http.IntegrationTests (1)

MtomBindingTestHelper.cs (1)

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

BoundTreeGenerator (1)

Program.cs (1)

61using (var outfile = new StreamWriter(File.Open(outfilename, FileMode.Create), Encoding.UTF8))

BuildBoss (2)

OptProfCheckerUtil.cs (1)

105using var reader = new StreamReader(stream, Encoding.UTF8, detectEncodingFromByteOrderMarks: true, bufferSize: 2048, leaveOpen: true);

SharedUtil.cs (1)

19internal static Encoding Encoding { get; } = Encoding.UTF8;

BuildValidator (1)

Program.cs (1)

374var documents = JsonConvert.DeserializeAnonymousType(Encoding.UTF8.GetString(sourceLinkUtf8), new { documents = (Dictionary<string, string>?)null })?.documents

Client.TypedClient.IntegrationTests (3)

TypedProxyTests.4.0.0.cs (3)

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

ClientSample (2)

RawSample.cs (2)

86await output.WriteLineAsync(Encoding.UTF8.GetString(buffer.ToArray())); 106await output.WriteAsync(Encoding.UTF8.GetBytes(result));

ConfigurationSchemaGenerator.Tests (1)

GeneratorTests.cs (1)

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

Contract.Service.IntegrationTests (2)

ServiceContractTests.4.0.0.cs (2)

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

CorsMiddlewareWebSite (1)

EchoMiddleware.cs (1)

29return context.Response.WriteAsync(path, Encoding.UTF8);

csc (2)

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

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

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

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

CSharpErrorFactsGenerator (1)

Program.cs (1)

135File.WriteAllText(outputPath, outputText.ToString(), Encoding.UTF8);

CSharpSyntaxGenerator (2)

Program.cs (2)

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

CustomAuthorizationFailureResponse (1)

Authorization\SampleAuthorizationMiddlewareResultHandler.cs (1)

58httpContext.Response.OnStarting(() => httpContext.Response.BodyWriter.WriteAsync(Encoding.UTF8.GetBytes(message)).AsTask());

dotnet-getdocument (1)

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

28Console.OutputEncoding = Encoding.UTF8;

dotnet-razorpagegenerator (1)

Program.cs (1)

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

dotnet-svcutil.xmlserializer (1)

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

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

dotnet-svcutil-lib (53)

CodeDomFixup\MethodCreationHelper.cs (1)

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

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

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

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

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

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

3252_ps.encoding = Encoding.UTF8;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

15internal static readonly Encoding Utf8WithoutPreamble = Encoding.UTF8;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Metadata\ServiceDescriptor.cs (2)

127Encoding encoding = Encoding.UTF8; 132Encoding.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;

dotnet-user-secrets (1)

Internal\SecretsStore.cs (1)

89File.WriteAllText(_secretsFilePath, contents.ToString(), Encoding.UTF8);

Encoding.MessageVersion.IntegrationTests (7)

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

ExceptionHandlerSample (1)

StartupWithWebSocket.cs (1)

32await ws.SendAsync(new ArraySegment<byte>(Encoding.UTF8.GetBytes("Hello")), System.Net.WebSockets.WebSocketMessageType.Text, true, context.RequestAborted);

Extensibility.MessageEncoder.IntegrationTests (2)

TextTests.4.1.0.cs (2)

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

FilesWebSite (3)

Controllers\DownloadFilesController.cs (3)

99var data = Encoding.UTF8.GetBytes("This is a sample text from a binary array"); 105var data = Encoding.UTF8.GetBytes("This is a sample text from a binary array"); 111var data = Encoding.UTF8.GetBytes("This is a sample text from a binary array");

FormatterWebSite (1)

StringInputFormatter.cs (1)

16SupportedEncodings.Add(Encoding.UTF8);

GenerateDocumentationAndConfigFiles (9)

Program.cs (1)

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

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

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

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

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

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

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

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

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

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

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

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

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

GetDocument.Insider (1)

ProgramBase.cs (1)

28Console.OutputEncoding = Encoding.UTF8;

http2cat (1)

Program.cs (1)

60h2Connection.Logger.LogInformation(Encoding.UTF8.GetString(dataFrame.Payload.ToArray()));

HttpStress (1)

Program.cs (1)

694public StringDuplexContent(string value) => _data = Encoding.UTF8.GetBytes(value);

IdeCoreBenchmarks (1)

ProjectOperationBenchmarks.cs (1)

68var emptySourceText = SourceText.From("", Encoding.UTF8);

IdentitySample.PasskeyConformance (1)

Program.cs (1)

235var resultJson = Encoding.UTF8.GetString(resultBytes);

IIS.FunctionalTests (7)

src\Servers\IIS\IIS\test\Common.FunctionalTests\Http2Tests.cs (5)

161await h2Connection.SendDataAsync(1, Encoding.UTF8.GetBytes("Hello World"), endStream: true); 189Assert.Equal("Hello World", Encoding.UTF8.GetString(dataFrame.Payload.Span)); 230await h2Connection.SendDataAsync(1, Encoding.UTF8.GetBytes("Hello World"), endStream: true); 258Assert.Equal("Hello World", Encoding.UTF8.GetString(dataFrame.Payload.Span)); 303Assert.Equal("Hello World", Encoding.UTF8.GetString(dataFrame.Payload.Span));

src\Servers\IIS\IIS\test\Common.FunctionalTests\RequestPathBaseTests.cs (1)

96return (status, Encoding.UTF8.GetString(bytes0.Span));

src\Servers\IIS\IIS\test\Common.FunctionalTests\RequestResponseTests.cs (1)

806return (status, Encoding.UTF8.GetString(bytes0.Span));

IIS.Microbenchmarks (1)

PlaintextBenchmark.cs (1)

45private static readonly byte[] _helloWorldPayload = Encoding.UTF8.GetBytes("Hello, World!");

IISExpress.FunctionalTests (7)

src\Servers\IIS\IIS\test\Common.FunctionalTests\Http2Tests.cs (5)

src\Servers\IIS\IIS\test\Common.FunctionalTests\RequestPathBaseTests.cs (1)

96return (status, Encoding.UTF8.GetString(bytes0.Span));

src\Servers\IIS\IIS\test\Common.FunctionalTests\RequestResponseTests.cs (1)

806return (status, Encoding.UTF8.GetString(bytes0.Span));

illink (2)

Linker\CustomSymbolWriter.cs (2)

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

Infrastructure.Common (2)

SafeKeychainHandle.cs (2)

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

InMemory.FunctionalTests (47)

Http2\Http2StreamTests.cs (19)

Http3\Http3StreamTests.cs (22)

HttpsConnectionMiddlewareTests.cs (3)

1102var request = Encoding.UTF8.GetBytes($"POST / HTTP/1.1\r\nHost: localhost\r\nContent-Length: {expectedBody.Length}\r\n\r\n{expectedBody}"); 1522var request = body == null ? Encoding.UTF8.GetBytes("GET / HTTP/1.0\r\n\r\n") 1523: Encoding.UTF8.GetBytes($"POST / HTTP/1.0\r\nContent-Length: {body.Length}\r\n\r\n{body}");

KestrelMetricsTests.cs (1)

286await c.Response.BodyWriter.WriteAsync(Encoding.UTF8.GetBytes("Hello world"));

ResponseHeaderTests.cs (2)

50testContext.ServerOptions.ResponseHeaderEncodingSelector = _ => Encoding.UTF8; 63using var connection = server.CreateConnection(Encoding.UTF8);

InProcessWebSite (8)

Program.cs (1)

90Console.OutputEncoding = Encoding.UTF8;

src\Servers\IIS\IIS\test\testassets\shared\WebSockets\HandshakeHelpers.cs (1)

30byte[] mergedBytes = Encoding.UTF8.GetBytes(merged);

Startup.cs (6)

635await ctx.Response.WriteAsync(Encoding.UTF8.GetString(readBuffer, 0, result)); 648await ctx.Response.WriteAsync(Encoding.UTF8.GetString(readBuffer, 0, result)); 741await ctx.Response.WriteAsync(Encoding.UTF8.GetString(readBuffer, 0, result)); 743await ctx.Response.WriteAsync(Encoding.UTF8.GetString(readBuffer, 0, result)); 778await ctx.Response.WriteAsync(Encoding.UTF8.GetString(buffer)); 963await fileStream.WriteAsync(Encoding.UTF8.GetBytes(fileContent), 0, fileContent.Length);

Interop.FunctionalTests (10)

Http2WebSocketInteropTests.cs (4)

68Assert.Equal("Hello", Encoding.UTF8.GetString(bytes, 0, result.Count)); 70await ws.SendAsync(Encoding.UTF8.GetBytes("Hi there"), WebSocketMessageType.Text, endOfMessage: true, default); 86await wsClient.SendAsync(Encoding.UTF8.GetBytes("Hello"), WebSocketMessageType.Text, endOfMessage: true, default); 92Assert.Equal("Hi there", Encoding.UTF8.GetString(bytes, 0, result.Count));

Http3\Http3RequestTests.cs (1)

71private static readonly byte[] TestData = Encoding.UTF8.GetBytes("Hello world");

HttpClientHttp2InteropTests.cs (3)

354var result = Encoding.UTF8.GetString(readResult.Buffer.FirstSpan); 485var bytes = Encoding.UTF8.GetBytes(text); 1734Assert.Equal("Hello World", Encoding.UTF8.GetString(responseBuffer));

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

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

IOperationGenerator (2)

IOperationClassWriter.cs (2)

107using (_writer = new StreamWriter(File.Open(outFileName, FileMode.Create), Encoding.UTF8)) 161using (_writer = new StreamWriter(File.Open(Path.Combine(_location, "OperationKind.Generated.cs"), FileMode.Create), Encoding.UTF8))

LargeResponseApp (1)

Startup.cs (1)

19private static readonly byte[] _chunk = Encoding.UTF8.GetBytes(new string('a', _chunkSize));

Metrics (9)

Program.cs (1)

236metricFile = new XmlTextWriter(outputFile, Encoding.UTF8);

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

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

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

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

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

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

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

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

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

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

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

Metrics.Legacy (9)

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

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

src\RoslynAnalyzers\Tools\Metrics\Program.cs (1)

236metricFile = new XmlTextWriter(outputFile, Encoding.UTF8);

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

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

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

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

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

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

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

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

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

Microsoft.Arcade.Common (2)

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

Microsoft.Arcade.Test.Common (1)

MockFileSystem.cs (1)

105: base(fileSystem.FileExists(path) ? System.Text.Encoding.UTF8.GetBytes(fileSystem.Files[path]) : new byte[2048])

Microsoft.AspNetCore.Antiforgery (3)

Internal\AntiforgeryOptionsSetup.cs (1)

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

Internal\AntiforgerySerializationContext.cs (2)

53_reader = new BinaryReader(Stream, Encoding.UTF8, leaveOpen: true); 71_writer = new BinaryWriter(Stream, Encoding.UTF8, leaveOpen: true);

Microsoft.AspNetCore.App.Analyzers.Test (1)

Verifiers\CSharpSourceGeneratorVerifier.cs (1)

26(typeof(TSourceGenerator), generatedFileName, SourceText.From(generatedSource, Encoding.UTF8))

Microsoft.AspNetCore.Authentication.MicrosoftAccount (1)

MicrosoftAccountHandler.cs (1)

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

Microsoft.AspNetCore.Authentication.Negotiate (2)

Internal\LdapAdapter.cs (2)

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

Microsoft.AspNetCore.Authentication.OAuth (1)

OAuthHandler.cs (1)

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

Microsoft.AspNetCore.Authentication.OpenIdConnect (5)

OpenIdConnectHandler.cs (3)

288var buffer = Encoding.UTF8.GetBytes(content); 420var challengeBytes = SHA256.HashData(Encoding.UTF8.GetBytes(codeVerifier)); 535var buffer = Encoding.UTF8.GetBytes(content);

OpenIdConnectPostConfigureOptions.cs (2)

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

Microsoft.AspNetCore.Authentication.Test (29)

CookieTests.cs (1)

1984var xmlBytes = Encoding.UTF8.GetBytes(xml.ToString());

FacebookTests.cs (3)

344res.Content = new StringContent(graphResponse, Encoding.UTF8); 353res.Content = new StringContent(graphResponse, Encoding.UTF8); 489res.Content = new StringContent(text, Encoding.UTF8, "application/json");

GoogleTests.cs (1)

1133res.Content = new StringContent(text, Encoding.UTF8, "application/json");

JwtBearerTests.cs (5)

49var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(new string('a', 128))); 86var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(new string('a', 128))); 918var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(new string('a', 128))); 963var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(new string('a', 128))); 1274var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(new string('a', 128)));

JwtBearerTests_Handler.cs (5)

42var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(new string('a', 128))); 78var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(new string('a', 128))); 864var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(new string('a', 128))); 908var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(new string('a', 128))); 1342var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(new string('a', 128)));

MicrosoftAccountTests.cs (1)

436res.Content = new StringContent(text, Encoding.UTF8, "application/json");

OAuthTests.cs (1)

544res.Content = new StringContent(text, Encoding.UTF8, "application/json");

OpenIdConnect\TestSettings.cs (1)

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

SecureDataFormatTests.cs (2)

69return Encoding.UTF8.GetBytes(model); 74return Encoding.UTF8.GetString(data);

TestExtensions.cs (2)

60var xmlBytes = Encoding.UTF8.GetBytes(xml.ToString()); 77var xmlBytes = Encoding.UTF8.GetBytes(xml.ToString());

TwitterTests.cs (4)

493res.Content = new StringContent(graphResponse, Encoding.UTF8); 607Encoding.UTF8, 622Encoding.UTF8, 637Encoding.UTF8,

WsFederation\CustomStateDataFormat.cs (1)

49var stateDataAsBytes = Encoding.UTF8.GetBytes(state);

WsFederation\WsFederationTest.cs (1)

460var newResponse = new HttpResponseMessage() { Content = new StringContent(metadata, Encoding.UTF8, "text/xml") };

WsFederation\WsFederationTest_Handler.cs (1)

449var newResponse = new HttpResponseMessage() { Content = new StringContent(metadata, Encoding.UTF8, "text/xml") };

Microsoft.AspNetCore.Components (5)

PersistentState\PersistentServicesRegistry.cs (1)

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

PersistentState\PersistentStateValueProviderKeyResolver.cs (2)

96wroteKey = Encoding.UTF8.TryGetBytes(keySpan, currentBuffer, out var written); 197SHA256.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);

Microsoft.AspNetCore.Components.Endpoints (11)

Builder\ResourceCollectionUrlEndpoint.cs (3)

133if (Encoding.UTF8.TryGetBytes(value, buffer, out var written)) 139var length = Encoding.UTF8.GetByteCount(value); 147var bytesWritten = Encoding.UTF8.GetBytes(value, rented);

RazorComponentEndpointInvoker.cs (1)

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

Rendering\Buffering\BufferedTextWriter.cs (1)

23public override Encoding Encoding => Encoding.UTF8;

Rendering\EndpointHtmlRenderer.EventDispatch.cs (2)

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

Rendering\EndpointHtmlRenderer.Streaming.cs (1)

101var initializersBase64 = Convert.ToBase64String(Encoding.UTF8.GetBytes(_options.JavaScriptInitializers));

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

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

Binding\FormDataMapperTests.cs (6)

2011var expected = new FormFileCollection { new FormFile(new MemoryStream(Encoding.UTF8.GetBytes(expectedString)), 0, expectedString.Length, "file", "file.txt") }; 2031Assert.Equal(expectedString, Encoding.UTF8.GetString(buffer, 0, buffer.Length)); 2042new FormFile(new MemoryStream(Encoding.UTF8.GetBytes(expectedString1)), 0, expectedString1.Length, "file", "file1.txt"), 2043new FormFile(new MemoryStream(Encoding.UTF8.GetBytes(expectedString2)), 0, expectedString2.Length, "file", "file2.txt") 2066Assert.Equal(expectedString1, Encoding.UTF8.GetString(buffer1, 0, buffer1.Length)); 2073Assert.Equal(expectedString2, Encoding.UTF8.GetString(buffer2, 0, buffer2.Length));

Builder\TestFileProvider\TestFileInfo.cs (2)

28Length = Encoding.UTF8.GetByteCount(Content); 39var bytes = Encoding.UTF8.GetBytes(Content);

Microsoft.AspNetCore.Components.Server (5)

Circuits\CircuitPersistenceManager.cs (2)

72var rootComponents = Encoding.UTF8.GetString(state.RootComponents); 83var rootComponentsBytes = Encoding.UTF8.GetBytes(rootComponents);

Circuits\ServerComponentDeserializer.cs (1)

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

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

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

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

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

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

Circuits\RenderBatchWriterTest.cs (1)

300var value = Encoding.UTF8.GetString(bytes, tableEntryPos + numLEB128Bytes, length);

ElementReferenceJsonConverterTest.cs (5)

35var json = Encoding.UTF8.GetString(memoryStream.ToArray()); 45var bytes = Encoding.UTF8.GetBytes(json); 65var bytes = Encoding.UTF8.GetBytes(json); 81var bytes = Encoding.UTF8.GetBytes(json); 100var bytes = Encoding.UTF8.GetBytes(json);

ProtectedBrowserStorageTest.cs (5)

208var storedString = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes("This string is not even protected")); 328var plaintextString = Encoding.UTF8.GetString(plaintext); 330return Encoding.UTF8.GetBytes(fakeProtectedString); 336var protectedString = Encoding.UTF8.GetString(protectedData); 345return Encoding.UTF8.GetBytes(unprotectedString);

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

HtmlRendering\HtmlRendererTest.cs (1)

856var actual = Encoding.UTF8.GetString(ms.ToArray());

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

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

Microsoft.AspNetCore.Components.WebView (2)

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

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

StaticContentProvider.cs (1)

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

Microsoft.AspNetCore.Components.WebView.Maui (1)

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

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

Microsoft.AspNetCore.Components.WebView.Test (1)

StaticContentProviderTests.cs (1)

127return new MemoryStream(Encoding.UTF8.GetBytes(_fileContents));

Microsoft.AspNetCore.Components.WebView.WindowsForms (1)

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

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

Microsoft.AspNetCore.Components.WebView.Wpf (1)

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

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

Microsoft.AspNetCore.Cryptography.Internal.Tests (2)

Cng\CachedAlgorithmHandlesTests.cs (2)

18private static readonly byte[] _dataToHash = Encoding.UTF8.GetBytes("Sample input data."); 19private static readonly byte[] _hmacKey = Encoding.UTF8.GetBytes("Secret key material.");

Microsoft.AspNetCore.Cryptography.KeyDerivation (5)

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

Microsoft.AspNetCore.Cryptography.KeyDerivation.Tests (3)

Pbkdf2Tests.cs (3)

53byte[] salt = Encoding.UTF8.GetBytes("salt"); 69var salt = Encoding.UTF8.GetBytes("abcdefghijkl"); 183byte[] salt = Encoding.UTF8.GetBytes("salt");

Microsoft.AspNetCore.DataProtection (1)

Cng\DpapiSecretSerializerHelper.cs (1)

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

Microsoft.AspNetCore.DataProtection.Extensions.Tests (3)

DataProtectionAdvancedExtensionsTests.cs (3)

20var plaintextAsBytes = Encoding.UTF8.GetBytes("this is plaintext"); 36var plaintextAsBytes = Encoding.UTF8.GetBytes("this is plaintext"); 86mockDataProtector.Setup(o => o.Unprotect(new byte[] { 0x01, 0x02 }, out controlExpiration)).Returns(Encoding.UTF8.GetBytes("this is plaintext"));

Microsoft.AspNetCore.DataProtection.Tests (57)

AuthenticatedEncryption\ConfigurationModel\AuthenticatedEncryptorDescriptorDeserializerTests.cs (1)

17var masterKey = Convert.ToBase64String(Encoding.UTF8.GetBytes("[PLACEHOLDER]"));

AuthenticatedEncryption\ConfigurationModel\AuthenticatedEncryptorDescriptorTests.cs (2)

146var masterKey = Convert.ToBase64String(Encoding.UTF8.GetBytes("[PLACEHOLDER]")); 169var masterKey = Convert.ToBase64String(Encoding.UTF8.GetBytes("[PLACEHOLDER]"));

AuthenticatedEncryption\ConfigurationModel\CngCbcAuthenticatedEncryptorDescriptorDeserializerTests.cs (1)

20var masterKey = Convert.ToBase64String(Encoding.UTF8.GetBytes("[PLACEHOLDER]"));

AuthenticatedEncryption\ConfigurationModel\CngCbcAuthenticatedEncryptorDescriptorTests.cs (2)

14var masterKey = Convert.ToBase64String(Encoding.UTF8.GetBytes("[PLACEHOLDER]")); 44var masterKey = Convert.ToBase64String(Encoding.UTF8.GetBytes("[PLACEHOLDER]"));

AuthenticatedEncryption\ConfigurationModel\CngGcmAuthenticatedEncryptorDescriptorDeserializerTests.cs (1)

21var masterKey = Convert.ToBase64String(Encoding.UTF8.GetBytes("[PLACEHOLDER]"));

AuthenticatedEncryption\ConfigurationModel\CngGcmAuthenticatedEncryptorDescriptorTests.cs (2)

14var masterKey = Convert.ToBase64String(Encoding.UTF8.GetBytes("[PLACEHOLDER]")); 41var masterKey = Convert.ToBase64String(Encoding.UTF8.GetBytes("[PLACEHOLDER]"));

AuthenticatedEncryption\ConfigurationModel\ManagedAuthenticatedEncryptorDescriptorDeserializerTests.cs (4)

22var masterKey = Convert.ToBase64String(Encoding.UTF8.GetBytes("[PLACEHOLDER]")); 56var masterKey = Convert.ToBase64String(Encoding.UTF8.GetBytes("[PLACEHOLDER]")); 90var masterKey = Convert.ToBase64String(Encoding.UTF8.GetBytes("[PLACEHOLDER]")); 113var masterKey = Convert.ToBase64String(Encoding.UTF8.GetBytes("[PLACEHOLDER]"));

AuthenticatedEncryption\ConfigurationModel\ManagedAuthenticatedEncryptorDescriptorTests.cs (2)

15var masterKey = Convert.ToBase64String(Encoding.UTF8.GetBytes("[PLACEHOLDER]")); 47var masterKey = Convert.ToBase64String(Encoding.UTF8.GetBytes("[PLACEHOLDER]"));

Cng\CbcAuthenticatedEncryptorTests.cs (6)

24ArraySegment<byte> plaintext = new ArraySegment<byte>(Encoding.UTF8.GetBytes("plaintext")); 25ArraySegment<byte> aad = new ArraySegment<byte>(Encoding.UTF8.GetBytes("aad")); 45ArraySegment<byte> plaintext = new ArraySegment<byte>(Encoding.UTF8.GetBytes("plaintext")); 46ArraySegment<byte> aad = new ArraySegment<byte>(Encoding.UTF8.GetBytes("aad")); 78encryptor.Decrypt(new ArraySegment<byte>(validCiphertext), new ArraySegment<byte>(Encoding.UTF8.GetBytes("different aad"))); 87Secret kdk = new Secret(Encoding.UTF8.GetBytes("master key"));

Cng\GcmAuthenticatedEncryptorTests.cs (6)

21ArraySegment<byte> plaintext = new ArraySegment<byte>(Encoding.UTF8.GetBytes("plaintext")); 22ArraySegment<byte> aad = new ArraySegment<byte>(Encoding.UTF8.GetBytes("aad")); 39ArraySegment<byte> plaintext = new ArraySegment<byte>(Encoding.UTF8.GetBytes("plaintext")); 40ArraySegment<byte> aad = new ArraySegment<byte>(Encoding.UTF8.GetBytes("aad")); 72encryptor.Decrypt(new ArraySegment<byte>(validCiphertext), new ArraySegment<byte>(Encoding.UTF8.GetBytes("different aad"))); 81Secret kdk = new Secret(Encoding.UTF8.GetBytes("master key"));

EphemeralDataProtectionProviderTests.cs (3)

18byte[] bytes = Encoding.UTF8.GetBytes("Hello there!"); 36byte[] bytes = Encoding.UTF8.GetBytes("Hello there!"); 53byte[] bytes = Encoding.UTF8.GetBytes("Hello there!");

Managed\ManagedAuthenticatedEncryptorTests.cs (6)

20ArraySegment<byte> plaintext = new ArraySegment<byte>(Encoding.UTF8.GetBytes("plaintext")); 21ArraySegment<byte> aad = new ArraySegment<byte>(Encoding.UTF8.GetBytes("aad")); 40ArraySegment<byte> plaintext = new ArraySegment<byte>(Encoding.UTF8.GetBytes("plaintext")); 41ArraySegment<byte> aad = new ArraySegment<byte>(Encoding.UTF8.GetBytes("aad")); 73encryptor.Decrypt(new ArraySegment<byte>(validCiphertext), new ArraySegment<byte>(Encoding.UTF8.GetBytes("different aad"))); 81Secret kdk = new Secret(Encoding.UTF8.GetBytes("master key"));

SP800_108\SP800_108Tests.cs (21)

Microsoft.AspNetCore.Diagnostics (1)

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

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

Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore (1)

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

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

Microsoft.AspNetCore.Diagnostics.HealthChecks (3)

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

Microsoft.AspNetCore.Diagnostics.Tests (1)

ExceptionDetailsProviderTest.cs (1)

311using (var writer = new StreamWriter(_stream, Encoding.UTF8, 1024, leaveOpen: true))

Microsoft.AspNetCore.Grpc.JsonTranscoding (6)

Internal\JsonRequestHelpers.cs (3)

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

Internal\JsonTranscodingServerCallContext.cs (2)

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

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

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

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

ConverterTests\JsonConverterWriteTests.cs (2)

192BytesValue = ByteString.CopyFrom(Encoding.UTF8.GetBytes("Hello world")), 211BytesValue = new BytesValue { Value = ByteString.CopyFrom(Encoding.UTF8.GetBytes("Hello world")) },

ServerStreamingServerCallHandlerTests.cs (3)

217Data = ByteString.CopyFrom(Encoding.UTF8.GetBytes($"<message>Hello {r.Name} 1</message>")) 223Data = ByteString.CopyFrom(Encoding.UTF8.GetBytes($"<message>Hello {r.Name} 2</message>")) 297return Encoding.UTF8.GetString(line);

TestObjects\Services\HttpBodyService.cs (1)

19Data = ByteString.CopyFrom(Encoding.UTF8.GetBytes(@"<message>Hello world</message>"))

UnaryServerCallHandlerTests.cs (15)

Microsoft.AspNetCore.Http (1)

Features\FormFeature.cs (1)

340return Encoding.UTF8;

Microsoft.AspNetCore.Http.Abstractions (2)

Extensions\HttpResponseWritingExtensions.cs (2)

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

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

HttpResponseWritingExtensionsTests.cs (1)

81{ Encoding.UTF8 }

HttpValidationProblemDetailsJsonConverterTest.cs (2)

59var reader = new Utf8JsonReader(Encoding.UTF8.GetBytes(json)); 102var reader = new Utf8JsonReader(Encoding.UTF8.GetBytes(json));

ProblemDetailsJsonConverterTest.cs (6)

25var reader = new Utf8JsonReader(Encoding.UTF8.GetBytes(json)); 42var reader = new Utf8JsonReader(Encoding.UTF8.GetBytes(json)); 137var reader = new Utf8JsonReader(Encoding.UTF8.GetBytes(json)); 185var actual = Encoding.UTF8.GetString(stream.ToArray()); 209var actual = Encoding.UTF8.GetString(stream.ToArray()); 240var actual = Encoding.UTF8.GetString(stream.ToArray());

Microsoft.AspNetCore.Http.Connections.Tests (57)

HttpConnectionDispatcherTests.cs (36)

LongPollingTests.cs (6)

75await connection.Transport.Output.WriteAsync(Encoding.UTF8.GetBytes("Hello World")); 81Assert.Equal("Hello World", Encoding.UTF8.GetString(ms.ToArray())); 98await connection.Transport.Output.WriteAsync(Encoding.UTF8.GetBytes("Hello")); 99await connection.Transport.Output.WriteAsync(Encoding.UTF8.GetBytes(" ")); 100await connection.Transport.Output.WriteAsync(Encoding.UTF8.GetBytes("World")); 109Assert.Equal("Hello World", Encoding.UTF8.GetString(payload));

NegotiateProtocolTests.cs (5)

31var responseData = Encoding.UTF8.GetBytes(json); 60var responseData = Encoding.UTF8.GetBytes(payload); 80var responseData = Encoding.UTF8.GetBytes(payload); 94string json = Encoding.UTF8.GetString(writer.ToArray()); 113string json = Encoding.UTF8.GetString(writer.ToArray());

ServerSentEventsMessageFormatterTests.cs (4)

20var buffer = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes(payload)); 25Assert.Equal(encoded, Encoding.UTF8.GetString(output.ToArray())); 32var buffer = ReadOnlySequenceFactory.SegmentPerByteFactory.CreateWithContent(Encoding.UTF8.GetBytes(payload)); 37Assert.Equal(encoded, Encoding.UTF8.GetString(output.ToArray()));

ServerSentEventsTests.cs (2)

124await connection.Transport.Output.WriteAsync(Encoding.UTF8.GetBytes(message)); 130Assert.Equal(expected, Encoding.UTF8.GetString(ms.ToArray()));

WebSocketsTests.cs (4)

48buffer: new ArraySegment<byte>(Encoding.UTF8.GetBytes("Hello")), 56Assert.Equal("Hello", Encoding.UTF8.GetString(buffer.ToArray())); 95await connection.Transport.Output.WriteAsync(Encoding.UTF8.GetBytes("Hello")); 106Assert.Equal("Hello", Encoding.UTF8.GetString(clientSummary.Received[0].Buffer));

Microsoft.AspNetCore.Http.Extensions (13)

HttpRequestJsonExtensions.cs (11)

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

SessionExtensions.cs (2)

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

Microsoft.AspNetCore.Http.Extensions.Tests (64)

HttpRequestJsonExtensionsTests.cs (7)

70context.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes("1")); 85context.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes("[1,2,]")); 106context.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes("[1,2]")); 173context.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes("1")); 217context.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes("[1,2,]")); 238context.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes("[1,2,]")); 260context.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes("[1,2,]"));

HttpResponseJsonExtensionsTests.cs (9)

ProblemDetailsServiceTest.cs (3)

33Assert.Equal("\"SecondWriter\"", Encoding.UTF8.GetString(stream.ToArray())); 60Assert.Equal("\"SecondWriter\"", Encoding.UTF8.GetString(stream.ToArray())); 110Assert.Equal(string.Empty, Encoding.UTF8.GetString(stream.ToArray()));

RequestDelegateFactoryTests.cs (12)

RequestDelegateGenerator\CompileTimeCreationTests.cs (10)

RequestDelegateGenerator\RequestDelegateCreationTestBase.cs (2)

137var encoding = text.Encoding ?? Encoding.UTF8; 306var project = _baseProject.AddDocument("TestMapActions.cs", SourceText.From(source, Encoding.UTF8)).Project;

RequestDelegateGenerator\RequestDelegateCreationTests.Filters.cs (1)

225var fileContent = new StringContent("hello", Encoding.UTF8, "application/octet-stream");

RequestDelegateGenerator\RequestDelegateCreationTests.Forms.cs (16)

RequestDelegateGenerator\RequestDelegateCreationTests.Logging.cs (2)

599httpContext.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes("{")); 639httpContext.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes("{"));

RequestDelegateGenerator\RequestDelegateCreationTests.QueryParameters.cs (1)

78var decodedResponseBody = Encoding.UTF8.GetString(responseBodyStream.ToArray());

ValidationEndpointConventionBuilderExtensionsTests.cs (1)

59Assert.Equal("Validation disabled here.", Encoding.UTF8.GetString(ms.ToArray()));

Microsoft.AspNetCore.Http.Microbenchmarks (3)

RequestDelegateGeneratorBenchmarks.cs (1)

32project = project.AddDocument("TestMapActions.cs", SourceText.From(source, Encoding.UTF8)).Project;

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

137var encoding = text.Encoding ?? Encoding.UTF8; 306var project = _baseProject.AddDocument("TestMapActions.cs", SourceText.From(source, Encoding.UTF8)).Project;

Microsoft.AspNetCore.Http.Results (1)

HttpResultsHelper.cs (1)

20private static readonly Encoding DefaultEncoding = Encoding.UTF8;

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

AcceptedAtRouteOfTResultTests.cs (1)

59var response = Encoding.UTF8.GetString(stream.ToArray());

AcceptedOfTResultTests.cs (1)

28var response = Encoding.UTF8.GetString(stream.ToArray());

BadRequestOfTResultTests.cs (1)

81Assert.Equal("\"Hello\"", Encoding.UTF8.GetString(stream.ToArray()));

ConflictOfTResultTests.cs (1)

80Assert.Equal("\"Hello\"", Encoding.UTF8.GetString(stream.ToArray()));

CreatedOfTResultTests.cs (1)

93var response = Encoding.UTF8.GetString(stream.ToArray());

InternalServerErrorOfTResultTests.cs (1)

81Assert.Equal("\"Hello\"", Encoding.UTF8.GetString(stream.ToArray()));

JsonResultTests.cs (2)

77Assert.Equal("\"Hello\"", Encoding.UTF8.GetString(stream.ToArray())); 114Assert.Equal(JsonSerializer.Serialize(value, options: jsonOptions), Encoding.UTF8.GetString(stream.ToArray()));

OkOfTResultTests.cs (1)

62Assert.Equal("\"Hello\"", Encoding.UTF8.GetString(stream.ToArray()));

PushStreamResultTests.cs (4)

15var result = new PushStreamHttpResult(body => body.WriteAsync(Encoding.UTF8.GetBytes("Hello World").AsMemory()).AsTask(), contentType: null); 26Assert.Equal("Hello World", Encoding.UTF8.GetString(ms.ToArray())); 37var callback = (Stream body) => body.WriteAsync(Encoding.UTF8.GetBytes("Hello World").AsMemory()).AsTask(); 55var callback = (Stream body) => body.WriteAsync(Encoding.UTF8.GetBytes("Hello World").AsMemory()).AsTask();

ResultsTests.cs (2)

541var encoding = Encoding.UTF8; 558var encoding = Encoding.UTF8;

ServerSentEventsResultTests.cs (11)

src\Shared\ResultsTests\FileStreamResultTestBase.cs (1)

425var readStream = new MemoryStream(Encoding.UTF8.GetBytes("Hello, World!"));

src\Shared\ResultsTests\VirtualFileResultTestBase.cs (1)

443var sourceStream = new MemoryStream(Encoding.UTF8.GetBytes(expectedData));

TypedResultsTests.cs (2)

537var encoding = Encoding.UTF8; 554var encoding = Encoding.UTF8;

UnprocessableEntityOfTResultTests.cs (1)

79Assert.Equal("\"Hello\"", Encoding.UTF8.GetString(stream.ToArray()));

Microsoft.AspNetCore.Http.Tests (26)

Features\FormFeatureTests.cs (26)

Microsoft.AspNetCore.HttpLogging (7)

MediaTypeHelpers.cs (1)

15Encoding.UTF8,

MediaTypeOptions.cs (6)

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

Microsoft.AspNetCore.HttpLogging.Tests (13)

HttpLoggingMiddlewareTests.cs (13)

Microsoft.AspNetCore.Identity (7)

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)

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

Passkeys\BufferSource.cs (2)

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

Microsoft.AspNetCore.Identity.EntityFrameworkCore.Test (1)

src\Identity\test\Shared\MockHelpers.cs (1)

98return Convert.ToBase64String(Encoding.UTF8.GetBytes(i)).ToUpperInvariant();

Microsoft.AspNetCore.Identity.InMemory.Test (2)

FunctionalTest.cs (1)

420using (var writer = XmlWriter.Create(memory, new XmlWriterSettings { Encoding = Encoding.UTF8 }))

src\Identity\test\Shared\MockHelpers.cs (1)

98return Convert.ToBase64String(Encoding.UTF8.GetBytes(i)).ToUpperInvariant();

Microsoft.AspNetCore.Identity.Test (7)

Passkeys\JsonHelpers.cs (1)

20=> value is null ? "null" : $"\"{Base64Url.EncodeToString(Encoding.UTF8.GetBytes(value))}\"";

Passkeys\PasskeyHandlerAssertionTest.cs (3)

444credentialJson["response"]!["userHandle"] = Base64Url.EncodeToString(Encoding.UTF8.GetBytes(newUserId)); 1063RpIdHash = SHA256.HashData(Encoding.UTF8.GetBytes(requestOptions.RpId ?? string.Empty)), 1075var clientDataJsonBytes = Encoding.UTF8.GetBytes(clientDataJson?.ToString() ?? string.Empty);

Passkeys\PasskeyHandlerAttestationTest.cs (2)

727test.AttestationObject.Transform(bytes => Encoding.UTF8.GetBytes("Not a CBOR map")); 1053RpIdHash = SHA256.HashData(Encoding.UTF8.GetBytes(creationOptions.Rp.Id ?? string.Empty)),

src\Identity\test\Shared\MockHelpers.cs (1)

98return Convert.ToBase64String(Encoding.UTF8.GetBytes(i)).ToUpperInvariant();

Microsoft.AspNetCore.Identity.UI (20)

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

Microsoft.AspNetCore.Mvc.Core (16)

Formatters\StringOutputFormatter.cs (1)

20SupportedEncodings.Add(Encoding.UTF8);

Formatters\SystemTextJsonInputFormatter.cs (2)

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

Formatters\SystemTextJsonOutputFormatter.cs (3)

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

Formatters\TextOutputFormatter.cs (2)

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

Infrastructure\ContentResultExecutor.cs (1)

44(DefaultContentType, Encoding.UTF8),

Infrastructure\IHttpRequestStreamReaderFactory.cs (1)

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

Infrastructure\IHttpResponseStreamWriterFactory.cs (1)

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

Infrastructure\SystemTextJsonResultExecutor.cs (4)

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

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

353return Encoding.UTF8;

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

ControllerBaseTest.cs (2)

2217var actualContentResult = controller.Content("TestContent", "text/plain", Encoding.UTF8); 2222Assert.Same(Encoding.UTF8, MediaType.GetEncoding(actualContentResult.ContentType));

Formatters\JsonInputFormatterTestBase.cs (22)

Formatters\JsonOutputFormatterTestBase.cs (2)

150await Record.ExceptionAsync(() => jsonFormatter.WriteResponseBodyAsync(outputFormatterContext, Encoding.UTF8)); 158var content = new StreamReader(body, Encoding.UTF8).ReadToEnd();

Formatters\ResponseContentTypeHelperTest.cs (3)

111(defaultContentType, Encoding.UTF8), 131(defaultContentType, Encoding.UTF8), 138Assert.Equal(Encoding.UTF8, resolvedContentTypeEncoding);

Formatters\StringOutputFormatterTests.cs (1)

132Encoding encoding = Encoding.UTF8;

Formatters\SystemTextJsonInputFormatterTest.cs (5)

71var contentBytes = Encoding.UTF8.GetBytes(content); 95var contentBytes = Encoding.UTF8.GetBytes("{\"dateValue\":\"not-a-date\"}"); 116var contentBytes = Encoding.UTF8.GetBytes("{\"shortValue\":\"32768\"}"); 144var contentBytes = Encoding.UTF8.GetBytes(content); 166var contentBytes = Encoding.UTF8.GetBytes("{");

Formatters\TextInputFormatterTest.cs (6)

91formatter.SupportedEncodings.Add(Encoding.UTF8); 106Assert.Equal(Encoding.UTF8, result); 117formatter.SupportedEncodings.Add(Encoding.UTF8); 132Assert.Equal(Encoding.UTF8, result); 184formatter.SupportedEncodings.Add(Encoding.UTF8); 200Assert.Equal(Encoding.UTF8, result);

Formatters\TextOutputFormatterTests.cs (2)

111formatter.SupportedEncodings.Add(Encoding.UTF8); 142formatter.SupportedEncodings.Add(Encoding.UTF8);

Infrastructure\DefaultOutputFormatterSelectorTest.cs (3)

399SupportedEncodings.Add(Encoding.UTF8); 415SupportedEncodings.Add(Encoding.UTF8); 430SupportedEncodings.Add(Encoding.UTF8);

Infrastructure\JsonResultExecutorTestBase.cs (9)

Infrastructure\ObjectResultExecutorTest.cs (3)

506SupportedEncodings.Add(Encoding.UTF8); 526SupportedEncodings.Add(Encoding.UTF8); 541SupportedEncodings.Add(Encoding.UTF8);

Infrastructure\ValidationProblemDetailsJsonConverterTest.cs (4)

26var reader = new Utf8JsonReader(Encoding.UTF8.GetBytes(json)); 68var reader = new Utf8JsonReader(Encoding.UTF8.GetBytes(json)); 152var json = Encoding.UTF8.GetString(stream.ToArray()); 185var json = Encoding.UTF8.GetString(stream.ToArray());

ModelBinding\Binders\BodyModelBinderTests.cs (9)

ModelBinding\Validation\DefaultObjectValidatorTests.cs (1)

1200var model = new MemoryStream(Encoding.UTF8.GetBytes("Hello!"));

src\Shared\ResultsTests\FileStreamResultTestBase.cs (1)

425var readStream = new MemoryStream(Encoding.UTF8.GetBytes("Hello, World!"));

src\Shared\ResultsTests\VirtualFileResultTestBase.cs (1)

443var sourceStream = new MemoryStream(Encoding.UTF8.GetBytes(expectedData));

Microsoft.AspNetCore.Mvc.Formatters.Xml (2)

XmlDataContractSerializerOutputFormatter.cs (1)

68SupportedEncodings.Add(Encoding.UTF8);

XmlSerializerOutputFormatter.cs (1)

67SupportedEncodings.Add(Encoding.UTF8);

Microsoft.AspNetCore.Mvc.Formatters.Xml.Test (54)

ProblemDetailsWrapperTest.cs (2)

29new MemoryStream(Encoding.UTF8.GetBytes(xml))); 90var res = new StreamReader(outputStream, Encoding.UTF8).ReadToEnd();

SerializableErrorWrapperTests.cs (2)

67new MemoryStream(Encoding.UTF8.GetBytes(serializableErrorXml))); 120var res = new StreamReader(outputStream, Encoding.UTF8).ReadToEnd();

ValidationProblemDetailsWrapperTest.cs (5)

33new MemoryStream(Encoding.UTF8.GetBytes(xml))); 89new MemoryStream(Encoding.UTF8.GetBytes(xml))); 127new MemoryStream(Encoding.UTF8.GetBytes(xml))); 179var res = new StreamReader(outputStream, Encoding.UTF8).ReadToEnd(); 217var res = new StreamReader(outputStream, Encoding.UTF8).ReadToEnd();

XmlDataContractSerializerInputFormatterTest.cs (23)

XmlDataContractSerializerOutputFormatterTest.cs (1)

778Assert.Contains("<int>1</int><int>2</int>", Encoding.UTF8.GetString(body.ToArray()));

XmlSerializerInputFormatterTest.cs (20)

XmlSerializerOutputFormatterTest.cs (1)

560Assert.Contains("<int>1</int><int>2</int>", Encoding.UTF8.GetString(body.ToArray()));

Microsoft.AspNetCore.Mvc.FunctionalTests (48)

ApiBehaviorTest.cs (1)

105Content = new StringContent("some content", Encoding.UTF8, "text/css"),

ConsumesAttributeTestsBase.cs (5)

102request.Content = new StringContent(input, Encoding.UTF8, requestContentType); 123request.Content = new StringContent(input, Encoding.UTF8, requestContentType); 147request.Content = new StringContent(input, Encoding.UTF8, "application/xml"); 168request.Content = new StringContent(input, Encoding.UTF8, "application/vnd.example+json"); 191request.Content = new StringContent(input, Encoding.UTF8, "application/vnd.example+xml");

ContentNegotiationTest.cs (1)

403var content = new StringContent("1234", Encoding.UTF8, "application/custom");

DoNotRespectBrowserAcceptHeaderTests.cs (2)

100request.Content = new StringContent(requestData, Encoding.UTF8, "application/xml"); 131request.Content = new StringContent(requestData, Encoding.UTF8, "application/xml");

FiltersTest.cs (1)

89Content = new StringContent("Test", Encoding.UTF8, "application/json"),

HtmlGenerationTest.cs (1)

618requestMessage.Content = new StringContent(content, Encoding.UTF8, "application/json");

Infrastructure\ResourceFile.cs (1)

102var bytes = Encoding.UTF8.GetBytes(text);

InputFormatterTests.cs (2)

45var content = new StringContent(input, Encoding.UTF8, "application/xml"); 78var content = new StringContent("Test Content", Encoding.UTF8, contentType);

InputObjectValidationTests.cs (12)

InputParentValidationTests.cs (1)

88return new StringContent(JsonConvert.SerializeObject(model), Encoding.UTF8, "application/json");

JsonInputFormatterTestBase.cs (6)

47var content = new StringContent(input, Encoding.UTF8, requestContentType); 66var content = new StringContent(jsonInput, Encoding.UTF8, requestContentType); 84var content = new StringContent(input, Encoding.UTF8, "application/json"); 100var content = new StringContent(expected, Encoding.UTF8, "application/json"); 203var content = new StringContent(jsonInput, Encoding.UTF8, "application/json"); 222var content = new StringContent(jsonInput, Encoding.UTF8, requestContentType);

JsonOutputFormatterTestBase.cs (1)

53request.Content = new StringContent(input, Encoding.UTF8, "application/xml");

JsonPatchInputFormatterTest.cs (1)

167Content = new StringContent(body, Encoding.UTF8, "application/json-patch+json"),

NewtonsoftJsonInputFormatterTest.cs (3)

16var content = new StringContent("{", Encoding.UTF8, "application/json"); 35var content = new StringContent(jsonInput, Encoding.UTF8, requestContentType); 52var content = new StringContent(jsonInput, Encoding.UTF8, requestContentType);

RequestSizeLimitTest.cs (1)

83request.Content = new StringContent(expected, Encoding.UTF8, "text/json");

RoutingFallbackTest.cs (1)

138Content = new StringContent("some plaintext", Encoding.UTF8, "text/plain"),

SerializableErrorTests.cs (3)

74Content = new StringContent(expectedXml, Encoding.UTF8, acceptHeader) 122request.Content = new StringContent(inputXml, Encoding.UTF8, acceptHeader); 163request.Content = new StringContent(inputXml, Encoding.UTF8, acceptHeader);

XmlDataContractSerializerInputFormatterTest.cs (3)

40var content = new StringContent(input, Encoding.UTF8, "application/xml-dcs"); 59request.Content = new StringContent(input, Encoding.UTF8, "application/xml-dcs"); 87request.Content = new StringContent(input, Encoding.UTF8, "application/xml-dcs");

XmlSerializerInputFormatterTests.cs (2)

41var content = new StringContent(input, Encoding.UTF8, "application/xml-xmlser"); 58var content = new StringContent(input, Encoding.UTF8, "application/xml-xmlser");

Microsoft.AspNetCore.Mvc.IntegrationTests (41)

BindingSourceMetadataProviderIntegrationTest.cs (1)

138var memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(data));

BodyValidationIntegrationTests.cs (19)

ComplexRecordIntegrationTest.cs (1)

4229var memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(content));

ComplexTypeIntegrationTestBase.cs (1)

3728var memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(content));

FormCollectionModelBindingIntegrationTest.cs (1)

161var memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(data));

FormFileModelBindingIntegrationTest.cs (1)

1273var memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(data));

JQueryFormatModelBindingIntegrationTest.cs (1)

68request.Body = new MemoryStream(Encoding.UTF8.GetBytes(

SimpleTypeModelBinderIntegrationTest.cs (1)

294request.Body = new MemoryStream(Encoding.UTF8.GetBytes(input));

TryUpdateModelIntegrationTest.cs (1)

1284var memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(data));

ValidationIntegrationTests.cs (7)

98request.Body = new MemoryStream(Encoding.UTF8.GetBytes("{\"accountId\": 15,\"amount\": 250.0}")); 140request.Body = new MemoryStream(Encoding.UTF8.GetBytes("{\"accountId\": 40,\"amount\": 250.0}")); 1737request.Body = new MemoryStream(Encoding.UTF8.GetBytes(input)); 1791request.Body = new MemoryStream(Encoding.UTF8.GetBytes("{ message: \"Hello\" }")); 1881request.Body = new MemoryStream(Encoding.UTF8.GetBytes("{ message: \"Hello\" }")); 1928request.Body = new MemoryStream(Encoding.UTF8.GetBytes("{ message: \"Hello There\" }")); 1986request.Body = new MemoryStream(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(input)));

ValidationWithRecordIntegrationTests.cs (7)

90request.Body = new MemoryStream(Encoding.UTF8.GetBytes("{\"accountId\": 15,\"amount\": 250.0}")); 132request.Body = new MemoryStream(Encoding.UTF8.GetBytes("{\"accountId\": 40,\"amount\": 250.0}")); 1540request.Body = new MemoryStream(Encoding.UTF8.GetBytes(input)); 1594request.Body = new MemoryStream(Encoding.UTF8.GetBytes("{ message: \"Hello\" }")); 1684request.Body = new MemoryStream(Encoding.UTF8.GetBytes("{ message: \"Hello\" }")); 1731request.Body = new MemoryStream(Encoding.UTF8.GetBytes("{ message: \"Hello There\" }")); 1781request.Body = new MemoryStream(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(input)));

Microsoft.AspNetCore.Mvc.NewtonsoftJson (3)

NewtonsoftJsonOutputFormatter.cs (1)

69SupportedEncodings.Add(Encoding.UTF8);

NewtonsoftJsonResultExecutor.cs (2)

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

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

JsonResultTest.cs (1)

24var expected = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(value));

NewtonsoftJsonInputFormatterTest.cs (14)

NewtonsoftJsonOutputFormatterTest.cs (19)

NewtonsoftJsonPatchInputFormatterTest.cs (7)

36var contentBytes = Encoding.UTF8.GetBytes(content); 73var contentBytes = Encoding.UTF8.GetBytes(content); 110var contentBytes = Encoding.UTF8.GetBytes(content); 134var contentBytes = Encoding.UTF8.GetBytes(content); 163var contentBytes = Encoding.UTF8.GetBytes(content); 184var contentBytes = Encoding.UTF8.GetBytes(content); 209var contentBytes = Encoding.UTF8.GetBytes(content);

NewtonsoftJsonResultExecutorTest.cs (1)

49Assert.Equal(expected, Encoding.UTF8.GetString(written));

src\Mvc\Mvc.Core\test\Formatters\JsonInputFormatterTestBase.cs (22)

src\Mvc\Mvc.Core\test\Formatters\JsonOutputFormatterTestBase.cs (2)

150await Record.ExceptionAsync(() => jsonFormatter.WriteResponseBodyAsync(outputFormatterContext, Encoding.UTF8)); 158var content = new StreamReader(body, Encoding.UTF8).ReadToEnd();

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

Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation (1)

RuntimeViewCompiler.cs (1)

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

Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation.Test (2)

CompilerFailedExceptionFactoryTest.cs (1)

310var stream = new MemoryStream(Encoding.UTF8.GetBytes(template));

TestInfrastructure\TestRazorProjectItem.cs (1)

38var stream = new MemoryStream(Encoding.UTF8.GetBytes(Content));

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

RazorPageTest.cs (2)

1360var writer = new ViewBufferTextWriter(buffer, Encoding.UTF8); 1412writer = writer ?? new ViewBufferTextWriter(buffer, Encoding.UTF8);

Microsoft.AspNetCore.Mvc.RazorPages.Test (4)

PageModelTest.cs (2)

1602var actualContentResult = pageModel.Content("TestContent", "text/plain", Encoding.UTF8); 1607Assert.Same(Encoding.UTF8, MediaType.GetEncoding(actualContentResult.ContentType));

PageTest.cs (2)

1592var actualContentResult = page.Content("TestContent", "text/plain", Encoding.UTF8); 1597Assert.Same(Encoding.UTF8, MediaType.GetEncoding(actualContentResult.ContentType));

Microsoft.AspNetCore.Mvc.TagHelpers (5)

Cache\CacheTagKey.cs (1)

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

Cache\DistributedCacheTagHelperFormatter.cs (2)

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

Cache\DistributedCacheTagHelperService.cs (1)

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

PartialTagHelper.cs (1)

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

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

DefaultFileVersionProviderTest.cs (2)

173var stream = new TestableMemoryStream(Encoding.UTF8.GetBytes("Hello World!")); 309.Returns(() => new MemoryStream(Encoding.UTF8.GetBytes("Hello World!")));

DistributedCacheTagHelperTest.cs (2)

35var value = Encoding.UTF8.GetBytes("ok"); 77var value = Encoding.UTF8.GetBytes(childContent);

ImageTagHelperTest.cs (1)

367.Returns(() => new MemoryStream(Encoding.UTF8.GetBytes("Hello World!")));

JavaScriptResourcesTest.cs (4)

17var stream = new MemoryStream(Encoding.UTF8.GetBytes(resource)); 34var stream = new MemoryStream(Encoding.UTF8.GetBytes(resource)); 54var stream = new MemoryStream(Encoding.UTF8.GetBytes(resource)); 79var stream = new MemoryStream(Encoding.UTF8.GetBytes(resource));

LinkTagHelperTest.cs (1)

1177.Returns(() => new MemoryStream(Encoding.UTF8.GetBytes("Hello World!")));

ScriptTagHelperTest.cs (1)

1144.Returns(() => new MemoryStream(Encoding.UTF8.GetBytes("Hello World!")));

Microsoft.AspNetCore.Mvc.Testing.Tasks (1)

GenerateMvcTestManifestTask.cs (1)

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

Microsoft.AspNetCore.Mvc.ViewFeatures (3)

HtmlHelper.cs (1)

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

ViewComponentResultExecutor.cs (1)

89(ViewExecutor.DefaultContentType, Encoding.UTF8),

ViewExecutor.cs (1)

192(DefaultContentType, Encoding.UTF8),

Microsoft.AspNetCore.Mvc.ViewFeatures.Test (17)

Buffers\ViewBufferTextWriterTest.cs (7)

20var writer = new ViewBufferTextWriter(buffer, Encoding.UTF8); 42var writer = new ViewBufferTextWriter(buffer, Encoding.UTF8); 67var writer = new ViewBufferTextWriter(buffer, Encoding.UTF8); 87var writer = new ViewBufferTextWriter(buffer, Encoding.UTF8, new HtmlTestEncoder(), inner.Object); 110var writer = new ViewBufferTextWriter(buffer, Encoding.UTF8); 126var writer = new ViewBufferTextWriter(buffer, Encoding.UTF8); 147var writer = new ViewBufferTextWriter(buffer, Encoding.UTF8);

ControllerUnitTestabilityTests.cs (4)

147Assert.Equal(content, Encoding.UTF8.GetString(fileContentResult.FileContents)); 180using (var stream = new StreamReader(fileStreamResult.FileStream, Encoding.UTF8)) 765var contentArray = Encoding.UTF8.GetBytes(content); 771var memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(content));

CookieTempDataProviderTest.cs (1)

20private static readonly byte[] Bytes = Encoding.UTF8.GetBytes("test value");

SessionStateTempDataProviderTest.cs (1)

13private static readonly byte[] Bytes = Encoding.UTF8.GetBytes("test value");

ViewComponentResultTest.cs (1)

601ContentType = new MediaTypeHeaderValue("text/html") { Encoding = Encoding.UTF8 }.ToString(),

ViewExecutorTest.cs (3)

156Assert.Equal("abcd", Encoding.UTF8.GetString(memoryStream.ToArray())); 247Assert.Equal("abcd", Encoding.UTF8.GetString(memoryStream.ToArray())); 286Assert.Equal("abcd", Encoding.UTF8.GetString(memoryStream.ToArray()));

Microsoft.AspNetCore.Mvc.Views.TestCommon (4)

TestFileInfo.cs (2)

28Length = Encoding.UTF8.GetByteCount(Content); 39var bytes = Encoding.UTF8.GetBytes(Content);

TestRazorCompiledItem.cs (2)

49var bytes = SHA1.HashData(Encoding.UTF8.GetBytes(content)); 55var bytes = SHA256.HashData(Encoding.UTF8.GetBytes(content));

Microsoft.AspNetCore.OpenApi.SourceGenerators.Tests (3)

SnapshotTestHelper.cs (3)

82var xmlText = Encoding.UTF8.GetString(xmlStream.ToArray()); 125var encoding = text.Encoding ?? Encoding.UTF8; 566return SourceText.From(text, Encoding.UTF8);

Microsoft.AspNetCore.OpenApi.Tests (5)

Extensions\OpenApiEndpointRouteBuilderExtensionsTests.cs (4)

101var responseString = Encoding.UTF8.GetString(responseBodyStream.ToArray()); 132Assert.Equal("No OpenAPI document with the name 'v2' was found.", Encoding.UTF8.GetString(responseBodyStream.ToArray())); 181var responseString = Encoding.UTF8.GetString(responseBodyStream.ToArray()); 222var responseString = Encoding.UTF8.GetString(responseBodyStream.ToArray());

Services\OpenApiDocumentServiceTestsBase.cs (1)

106SupportedEncodings.Add(Encoding.UTF8);

Microsoft.AspNetCore.OutputCaching (4)

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

Microsoft.AspNetCore.OutputCaching.StackExchangeRedis (3)

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

Microsoft.AspNetCore.OutputCaching.Tests (5)

OutputCacheMiddlewareTests.cs (3)

911Assert.Equal("Hello1", Encoding.UTF8.GetString(memoryStream1.ToArray())); 912Assert.Equal("Hello2", Encoding.UTF8.GetString(memoryStream2.ToArray())); 1054var response = Encoding.UTF8.GetString(responseStream.GetBuffer());

TestUtils.cs (2)

86Encoding.UTF8.GetBytes(uniqueId, context.Response.BodyWriter); 282var data = Encoding.UTF8.GetBytes(text);

Microsoft.AspNetCore.Owin (1)

WebSockets\WebSocketAdapter.cs (1)

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

Microsoft.AspNetCore.Razor (1)

TagHelpers\DefaultTagHelperContent.cs (1)

309return Encoding.UTF8;

Microsoft.AspNetCore.RequestDecompression.Tests (1)

RequestDecompressionMiddlewareTests.cs (1)

28return Encoding.UTF8.GetBytes(input);

Microsoft.AspNetCore.ResponseCaching.Tests (1)

TestUtils.cs (1)

268byte[] data = Encoding.UTF8.GetBytes(text);

Microsoft.AspNetCore.Rewrite (1)

UrlActions\CustomResponseAction.cs (1)

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

Microsoft.AspNetCore.Routing (1)

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

353return Encoding.UTF8;

Microsoft.AspNetCore.Routing.Tests (7)

Builder\RequestDelegateEndpointRouteBuilderExtensionsTest.cs (4)

105var responseBody = Encoding.UTF8.GetString(responseBodyStream.ToArray()); 141var responseBody = Encoding.UTF8.GetString(responseBodyStream.ToArray()); 169var responseBody = Encoding.UTF8.GetString(responseBodyStream.ToArray()); 285var responseBody = Encoding.UTF8.GetString(responseBodyStream.ToArray());

EndpointRoutingMiddlewareFormOptionsTest.cs (3)

32httpContext.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes("foo=bar")); 64httpContext.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes("foo=bar")); 136httpContext.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes("foo=bar"));

Microsoft.AspNetCore.Server.HttpSys (4)

HttpSysOptions.cs (1)

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

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

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

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

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

Microsoft.AspNetCore.Server.HttpSys.FunctionalTests (14)

Http2Tests.cs (4)

192await h2Connection.SendDataAsync(1, Encoding.UTF8.GetBytes("Hello World"), endStream: true); 208Assert.Equal("Hello World", Encoding.UTF8.GetString(dataFrame.Payload.Span)); 256await h2Connection.SendDataAsync(1, Encoding.UTF8.GetBytes("Hello World"), endStream: true); 272Assert.Equal("Hello World", Encoding.UTF8.GetString(dataFrame.Payload.Span));

HttpsTests.cs (2)

42byte[] body = Encoding.UTF8.GetBytes("Hello World"); 59var body = Encoding.UTF8.GetBytes("Hello World");

Listener\RequestHeaderTests.cs (4)

25Task responseTask = SendRequestAsync(address, "Custom-Header", customValues, Encoding.UTF8); 66Task responseTask = SendRequestAsync(address, "Custom-Header", customValues, Encoding.UTF8); 162Task responseTask = SendRequestAsync(address, "If-None-Match", customValues, Encoding.UTF8); 187Task responseTask = SendRequestAsync(address, "Custom-Header", customValues, Encoding.UTF8);

RequestTests.cs (1)

392var statusCode = Encoding.UTF8.GetString(response).Substring(9);

ResponseBodyTests.cs (2)

408var data = Encoding.UTF8.GetBytes("hello, world"); 431Assert.Equal("hello, world", Encoding.UTF8.GetString(payload));

ResponseHeaderTests.cs (1)

128var socketsHttpHandler = new SocketsHttpHandler() { ResponseHeaderEncodingSelector = (_, _) => Encoding.UTF8 };

Microsoft.AspNetCore.Server.IIS (6)

Core\IISHttpContext.cs (3)

614var headerValueBytes = Encoding.UTF8.GetBytes(headerValue); 620var headerNameBytes = Encoding.UTF8.GetBytes(headerPair.Key); 659var headerValueBytes = Encoding.UTF8.GetBytes(headerValue);

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

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

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

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

Microsoft.AspNetCore.Server.Kestrel.Core (5)

Internal\Http\PathDecoder.cs (1)

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

Internal\Infrastructure\KestrelEventSource.cs (2)

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

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

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

Microsoft.AspNetCore.Server.Kestrel.Core.Tests (16)

Http1\Http1ConnectionTests.cs (5)

29var headerValue = Encoding.UTF8.GetString(headerValueBytes); 32await _application.Output.WriteAsync(Encoding.UTF8.GetBytes($"{headerName}: ")); 34await _application.Output.WriteAsync(Encoding.UTF8.GetBytes("\r\n\r\n")); 717var payload = Encoding.UTF8.GetBytes("hello, web browser" + new string(' ', 512) + "\n"); 731var payload = Encoding.UTF8.GetBytes("hello, web browser" + new string(' ', 512) + "\n");

Http2\Http2HPackEncoderTests.cs (1)

209var headers = (IHeaderDictionary)new HttpResponseHeaders(_ => Encoding.UTF8);

HttpRequestHeadersTests.cs (8)

551var prevSpan = Encoding.UTF8.GetBytes(headerValueUtf16Latin1CrossOver).AsSpan(); 672var headerValueBytes = Encoding.UTF8.GetBytes(headerValue); 682return Encoding.UTF8; 748var prevSpan = Encoding.UTF8.GetBytes(HeaderValue).AsSpan(); 796var prevSpan1 = Encoding.UTF8.GetBytes(HeaderValue1).AsSpan(); 797var prevSpan2 = Encoding.UTF8.GetBytes(HeaderValue2).AsSpan(); 850var prevSpan = Encoding.UTF8.GetBytes(prevValue).AsSpan(); 861var nextSpan = Encoding.UTF8.GetBytes(nextValue).AsSpan();

HttpResponseHeadersTests.cs (2)

190var responseHeaders = new HttpResponseHeaders(_ => Encoding.UTF8); 238var responseHeaders = new HttpResponseHeaders(_ => Encoding.UTF8);

Microsoft.AspNetCore.Server.Kestrel.Microbenchmarks (5)

Http2\HPackHeaderWriterBenchmark.cs (2)

61_knownResponseHeaders.EncodingSelector = _ => Encoding.UTF8; 76_knownResponseHeaders.EncodingSelector = _ => Encoding.UTF8;

InMemoryTransportBenchmark.cs (1)

240private static readonly byte[] _helloWorldPayload = Encoding.UTF8.GetBytes("Hello, World!");

KnownStringsBenchmark.cs (1)

24static readonly byte[] _version = Encoding.UTF8.GetBytes("HTTP/1.1\r\n");

NamedPipesTransportBenchmark.cs (1)

138private static readonly byte[] _helloWorldPayload = Encoding.UTF8.GetBytes("Hello, World!");

Microsoft.AspNetCore.Server.Kestrel.Transport.NamedPipes (2)

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

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

Microsoft.AspNetCore.Server.Kestrel.Transport.Quic (2)

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

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

Microsoft.AspNetCore.Server.Kestrel.Transport.Quic.Tests (4)

QuicConnectionContextTests.cs (1)

21private static readonly byte[] TestData = Encoding.UTF8.GetBytes("Hello world");

QuicConnectionListenerTests.cs (1)

25private static readonly byte[] TestData = Encoding.UTF8.GetBytes("Hello world");

QuicStreamContextTests.cs (1)

26private static readonly byte[] TestData = Encoding.UTF8.GetBytes("Hello world");

QuicTestHelpers.cs (1)

28private static readonly byte[] TestData = Encoding.UTF8.GetBytes("Hello world");

Microsoft.AspNetCore.Session (4)

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

Microsoft.AspNetCore.Shared.Tests (11)

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

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

UrlDecoderTests.cs (10)

Microsoft.AspNetCore.SignalR.Client.FunctionalTests (2)

HubProtocolVersionTests.cs (1)

142connectionContext.Transport.Output.Write(Encoding.UTF8.GetBytes(messageToken.ToString()));

VersionJsonHubProtocol.cs (1)

40var json = Encoding.UTF8.GetString(payload.ToArray());

Microsoft.AspNetCore.SignalR.Client.SourceGenerator (4)

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

Microsoft.AspNetCore.SignalR.Client.Tests (19)

HttpConnectionTests.Transport.cs (9)

HubConnectionTests.ConnectionLifecycle.cs (1)

626await innerConnection.Application.Output.WriteAsync(Encoding.UTF8.GetBytes(new[] { '{' })).DefaultTimeout();

LongPollingTransportTests.cs (4)

145Assert.Equal(Encoding.UTF8.GetBytes("HelloWorld"), data); 305await longPollingTransport.Output.WriteAsync(Encoding.UTF8.GetBytes("Hello World")); 501longPollingTransport.Output.Write(Encoding.UTF8.GetBytes("Hello")); 502longPollingTransport.Output.Write(Encoding.UTF8.GetBytes("World"));

SendUtilsTests.cs (1)

41await application.Output.WriteAsync(Encoding.UTF8.GetBytes("Hello World"));

ServerSentEventsTransportTests.cs (1)

515return new(Encoding.UTF8.GetBytes(_contents[_index++], buffer.Span));

TestConnection.cs (3)

107var bytes = FormatMessageToArray(Encoding.UTF8.GetBytes(json)); 114return ReceiveBytesAsync(Encoding.UTF8.GetBytes(rawText)); 157return Encoding.UTF8.GetString(payload.ToArray());

Microsoft.AspNetCore.SignalR.Common (2)

Protocol\HandshakeProtocol.cs (1)

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

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

26_decoder = Encoding.UTF8.GetDecoder();

Microsoft.AspNetCore.SignalR.Common.Tests (63)

Internal\Formatters\BinaryMessageFormatterTests.cs (2)

32Encoding.UTF8.GetBytes("Hello,\r\nWorld!") 102var message = Encoding.UTF8.GetBytes(payload);

Internal\Formatters\BinaryMessageParserTests.cs (2)

25Assert.Equal(Encoding.UTF8.GetBytes(payload), message.ToArray()); 109Assert.Equal(Encoding.UTF8.GetBytes("Hello,\r\nWorld!"), messages[1]);

Internal\Formatters\TextMessageFormatterTests.cs (2)

19var buffer = Encoding.UTF8.GetBytes("ABC"); 22Assert.Equal("ABC\u001e", Encoding.UTF8.GetString(ms.ToArray()));

Internal\Formatters\TextMessageParserTests.cs (9)

17var message = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes("ABC\u001e")); 20Assert.Equal("ABC", Encoding.UTF8.GetString(payload.ToArray())); 27var message = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes("ABC")); 34var message = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes("ABC\u001eXYZ\u001e")); 36Assert.Equal("ABC", Encoding.UTF8.GetString(payload.ToArray())); 38Assert.Equal("XYZ", Encoding.UTF8.GetString(payload.ToArray())); 44var message = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes("ABC\u001eXYZ\u001e123")); 46Assert.Equal("ABC", Encoding.UTF8.GetString(payload.ToArray())); 48Assert.Equal("XYZ", Encoding.UTF8.GetString(payload.ToArray()));

Internal\Protocol\HandshakeProtocolTests.cs (5)

26var message = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes(json)); 52var message = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes(json)); 71var message = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes("42")); 89var message = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes(payload)); 105var message = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes(payload));

Internal\Protocol\JsonHubProtocolTests.cs (10)

53var data = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes(input)); 71var json = Encoding.UTF8.GetString(writer.ToArray()); 90var data = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes(input)); 104var data = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes(input)); 126var json = Encoding.UTF8.GetString(writer.ToArray()); 130var data = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes(json)); 159var json = Encoding.UTF8.GetString(writer.ToArray()); 163var data = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes(json)); 192var json = Encoding.UTF8.GetString(writer.ToArray()); 196var data = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes(json));

Internal\Protocol\JsonHubProtocolTestsBase.cs (18)

Internal\Protocol\NewtonsoftJsonHubProtocolTests.cs (3)

51var data = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes(input)); 70var json = Encoding.UTF8.GetString(writer.ToArray()); 89var data = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes(input));

Internal\Protocol\Utf8BufferTextReaderTests.cs (5)

18var buffer = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes("Hello World")); 31var buffer = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes("a\u00E4\u00E4\u00a9o")); 49var buffer = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes("Hello World")); 63var buffer = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes("Hello World")); 95var buffer = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes("\u00E4\u00E4\u00E5"));

Internal\Protocol\Utf8BufferTextWriterTests.cs (7)

105var result = Encoding.UTF8.GetString(bufferWriter.CurrentSegment.Slice(0, bufferWriter.Position).ToArray()); 142var expectedData = Encoding.UTF8.GetBytes(fourCircles); 171var expectedData = Encoding.UTF8.GetBytes(fourCircles); 233Assert.Equal("Hello", Encoding.UTF8.GetString(bufferWriter1.ToArray())); 242Assert.Equal("World", Encoding.UTF8.GetString(bufferWriter2.ToArray())); 292Assert.Equal(testString, Encoding.UTF8.GetString(bufferWriter.ToArray())); 338var result = Encoding.UTF8.GetString(data);

Microsoft.AspNetCore.SignalR.Core (3)

Internal\Utf8HashLookup.cs (3)

39var encodedValue = Encoding.UTF8.GetBytes(value); 81var count = Encoding.UTF8.GetCharCount(encodedValue); 85var encoded = Encoding.UTF8.GetChars(encodedValue, chars);

Microsoft.AspNetCore.SignalR.Microbenchmarks (16)

HandshakeProtocolBenchmark.cs (12)

NegotiateProtocolBenchmark.cs (4)

43_responseData1 = Encoding.UTF8.GetBytes("{\"connectionId\":\"123\",\"availableTransports\":[]}"); 44_responseData2 = Encoding.UTF8.GetBytes("{\"url\": \"http://foo.com/chat\"}"); 45_responseData3 = Encoding.UTF8.GetBytes("{\"url\": \"http://foo.com/chat\", \"accessToken\": \"token\"}"); 46_responseData4 = Encoding.UTF8.GetBytes("{\"connectionId\":\"123\",\"availableTransports\":[{\"transport\":\"test\",\"transferFormats\":[]}]}");

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

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

26_decoder = Encoding.UTF8.GetDecoder();

Microsoft.AspNetCore.SignalR.Protocols.MessagePack (1)

Protocol\MessagePackHubProtocolWorker.cs (1)

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

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

Protocol\NewtonsoftJsonHubProtocol.cs (1)

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

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

26_decoder = Encoding.UTF8.GetDecoder();

Microsoft.AspNetCore.SignalR.StackExchangeRedis (1)

RedisHubLifetimeManager.cs (1)

841public override Encoding Encoding => Encoding.UTF8;

Microsoft.AspNetCore.SignalR.StackExchangeRedis.Tests (1)

RedisProtocolTests.cs (1)

207new RedisCompletion("json", new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes("{\"type\":3,\"invocationId\":\"1\",\"result\":1}"))),

Microsoft.AspNetCore.SignalR.Tests (38)

ClientProxyTests.cs (9)

33var data = Encoding.UTF8.GetBytes("Hello world"); 54var data = Encoding.UTF8.GetBytes("Hello world"); 75var data = Encoding.UTF8.GetBytes("Hello world"); 96var data = Encoding.UTF8.GetBytes("Hello world"); 117var data = Encoding.UTF8.GetBytes("Hello world"); 138var data = Encoding.UTF8.GetBytes("Hello world"); 159var data = Encoding.UTF8.GetBytes("Hello world"); 180var data = Encoding.UTF8.GetBytes("Hello world"); 201var data = Encoding.UTF8.GetBytes("Hello world");

EndToEndTests.cs (6)

102var bytes = Encoding.UTF8.GetBytes(message); 140var bytes = Encoding.UTF8.GetBytes(message); 274var bytes = Encoding.UTF8.GetBytes(message); 293Assert.Equal(message, Encoding.UTF8.GetString(await connection.Transport.Input.ReadAsync(bytes.Length).DefaultTimeout())); 331var bytes = Encoding.UTF8.GetBytes(message); 345Assert.Equal(message, Encoding.UTF8.GetString(receivedData));

HttpHeaderConnectionHandler.cs (2)

25var headerName = Encoding.UTF8.GetString(buffer.ToArray()); 28var data = Encoding.UTF8.GetBytes(string.Join(",", headerValues));

HubConnectionHandlerTests.cs (17)

WebSocketsTransportTests.cs (4)

112await webSocketsTransport.Output.WriteAsync(Encoding.UTF8.GetBytes("User-Agent")); 119var userAgent = Encoding.UTF8.GetString(result.Buffer.ToArray()); 143await webSocketsTransport.Output.WriteAsync(Encoding.UTF8.GetBytes(HeaderNames.XRequestedWith)); 150var headerValue = Encoding.UTF8.GetString(result.Buffer.ToArray());

Microsoft.AspNetCore.SpaProxy (1)

SpaProxyMiddleware.cs (1)

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

Microsoft.AspNetCore.StaticAssets.Tests (1)

StaticAssetsIntegrationTests.cs (1)

560var hash = SHA256.HashData(Encoding.UTF8.GetBytes(content));

Microsoft.AspNetCore.StaticFiles (1)

HtmlDirectoryFormatter.cs (1)

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

Microsoft.AspNetCore.TestHost.Tests (15)

ClientHandlerTests.cs (2)

130var contentBytes = Encoding.UTF8.GetBytes("This is a content!"); 192var contentBytes = Encoding.UTF8.GetBytes("This is a content!");

HttpContextBuilderTests.cs (2)

178var bytes = Encoding.UTF8.GetBytes("BodyStarted" + Environment.NewLine); 182bytes = Encoding.UTF8.GetBytes("BodyFinished");

TestClientTests.cs (11)

293Assert.Equal("STARTED", Encoding.UTF8.GetString(buffer, 0, length)); 296await requestStream.WriteAsync(Encoding.UTF8.GetBytes("Hello world")).AsTask().DefaultTimeout(); 302Assert.Equal("Hello world POST Response", Encoding.UTF8.GetString(buffer, 0, length)); 366Assert.Equal("SENT", Encoding.UTF8.GetString(serverBuffer, 0, serverLength)); 420await requestStream.WriteAsync(Encoding.UTF8.GetBytes("SENT")).AsTask().DefaultTimeout(); 483Assert.Equal("POST Response", Encoding.UTF8.GetString(buffer, 0, length)); 490await requestStream.WriteAsync(Encoding.UTF8.GetBytes(new string('!', 1024 * 1024 * 50))).AsTask().DefaultTimeout(); 680() => requestStream.WriteAsync(Encoding.UTF8.GetBytes("Hello world")).AsTask(), 763var hello = Encoding.UTF8.GetBytes("hello"); 765var world = Encoding.UTF8.GetBytes("world!"); 987var hello = Encoding.UTF8.GetBytes("hello");

Microsoft.AspNetCore.Tests (1)

WebApplicationTests.cs (1)

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

Microsoft.AspNetCore.WebSockets (1)

HandshakeHelpers.cs (1)

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

Microsoft.AspNetCore.WebSockets.Tests (12)

SendReceiveTests.cs (4)

17var sendBuffer = Encoding.UTF8.GetBytes(message); 25Assert.Equal(message, Encoding.UTF8.GetString(receiveBuffer, 0, result.Count)); 34var sendBuffer = Encoding.UTF8.GetBytes(message); 42Assert.Equal(message, Encoding.UTF8.GetString(receiveBuffer, 0, result.Count));

WebSocketMiddlewareTests.cs (8)

Microsoft.AspNetCore.WebUtilities (9)

BufferedReadStream.cs (1)

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

FormPipeReader.cs (5)

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

FormReader.cs (1)

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

MultipartBoundary.cs (1)

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

MultipartSectionStreamExtensions.cs (1)

43streamEncoding = Encoding.UTF8;

Microsoft.AspNetCore.WebUtilities.Microbenchmarks (8)

FormPipeReaderInternalsBenchmark.cs (3)

15private readonly byte[] _singleUtf8 = Encoding.UTF8.GetBytes("foo=bar&baz=boo&haha=hehe&lol=temp"); 16private readonly byte[] _firstUtf8 = Encoding.UTF8.GetBytes("foo=bar&baz=bo"); 17private readonly byte[] _secondUtf8 = Encoding.UTF8.GetBytes("o&haha=hehe&lol=temp");

FormReaderBenchmark.cs (2)

16var bytes = Encoding.UTF8.GetBytes("foo=bar&baz=boo"); 31var bytes = Encoding.UTF8.GetBytes("foo=bar&baz=boo");

HttpRequestStreamReaderReadLineBenchmark.cs (2)

25_stream = new MemoryStream(Encoding.UTF8.GetBytes(data)); 50return new HttpRequestStreamReader(_stream, Encoding.UTF8);

MultipartReaderBenchmark.cs (1)

90_stream = new MemoryStream(Encoding.UTF8.GetBytes(data));

Microsoft.AspNetCore.WebUtilities.Tests (89)

FileBufferingWriteStreamTests.cs (2)

24var input = Encoding.UTF8.GetBytes("Hello world"); 139var input = Encoding.UTF8.GetBytes("Hello world");

FormPipeReaderTests.cs (29)

FormReaderTests.cs (1)

217var formContent = Encoding.UTF8.GetBytes(text);

HttpRequestStreamReaderTest.cs (16)

HttpResponseStreamWriterTest.cs (33)

MultipartReaderTests.cs (5)

98return new MemoryStream(Encoding.UTF8.GetBytes(text)); 398var bytes = Encoding.UTF8.GetBytes(body1); 404bytes = Encoding.UTF8.GetBytes(body2); 433var bytes = Encoding.UTF8.GetBytes(body1); 439bytes = Encoding.UTF8.GetBytes(body2);

PagedByteBufferTest.cs (3)

16var input = Encoding.UTF8.GetBytes("Hello world"); 32var input1 = Encoding.UTF8.GetBytes("Hello"); 33var input2 = Encoding.UTF8.GetBytes("world");

Microsoft.Build.Framework (5)

EncodingUtilities.cs (4)

Telemetry\ActivityExtensions.cs (1)

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

Microsoft.Build.Tasks.CodeAnalysis (3)

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

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

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

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

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

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

Microsoft.Build.Tasks.CodeAnalysis.Sdk (3)

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

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

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

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

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

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

Microsoft.CodeAnalysis (22)

CommandLine\CommonCompiler.cs (2)

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

DiaSymReader\Writer\SymUnmanagedWriterImpl.cs (3)

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

InternalUtilities\StringTable.cs (1)

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

MetadataReader\PEModule.cs (1)

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

PEWriter\MetadataWriter.cs (1)

40internal static readonly Encoding s_utf8Encoding = Encoding.UTF8;

PEWriter\PeWriter.cs (1)

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

SourceGeneration\GeneratorContexts.cs (2)

82public void AddSource(string hintName, string source) => AddSource(hintName, SourceText.From(source, Encoding.UTF8)); 274public void AddSource(string hintName, string source) => AddSource(hintName, SourceText.From(source, Encoding.UTF8));

SourceGeneration\IncrementalContexts.cs (3)

124public void AddSource(string hintName, string source) => AddSource(hintName, SourceText.From(source, Encoding.UTF8)); 144public void AddEmbeddedAttributeDefinition() => AddSource("Microsoft.CodeAnalysis.EmbeddedAttribute", SourceText.From(_embeddedAttributeDefinition, encoding: Encoding.UTF8)); 171public void AddSource(string hintName, string source) => AddSource(hintName, SourceText.From(source, Encoding.UTF8));

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

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

Syntax\SyntaxNode.cs (1)

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

Text\SourceText.cs (6)

98/// If an encoding-less <see cref="SourceText"/> is written to a file a <see cref="Encoding.UTF8"/> shall be used as a default. 124/// If an encoding-less <see cref="SourceText"/> is written to a file a <see cref="Encoding.UTF8"/> shall be used as a default. 163/// <see cref="Encoding.UTF8"/> if not specified. 235/// <see cref="Encoding.UTF8"/> if not specified. 392/// If an encoding-less <see cref="SourceText"/> is written to a file a <see cref="Encoding.UTF8"/> shall be used as a default. 1254return Encoding.UTF8;

Microsoft.CodeAnalysis.Analyzers (8)

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

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

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

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

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

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

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

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

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

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

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

Microsoft.CodeAnalysis.AnalyzerUtilities (8)

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

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

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

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

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

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

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

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

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

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

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

Microsoft.CodeAnalysis.BannedApiAnalyzers (8)

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

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

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

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

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

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

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

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

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

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

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

Microsoft.CodeAnalysis.CodeStyle (7)

src\Analyzers\Core\Analyzers\Helpers\DiagnosticHelper.cs (1)

231return Encoding.UTF8.GetString(jsonBytes, 0, jsonBytes.Length);

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

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

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

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

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

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

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

Microsoft.CodeAnalysis.CodeStyle.UnitTestUtilities (2)

src\Features\DiagnosticsTestUtilities\CodeActions\CodeFixVerifierHelper.cs (2)

103return explicitEditorConfig is object ? SourceText.From(explicitEditorConfig, Encoding.UTF8) : null; 132return SourceText.From(analyzerConfig.ToString(), Encoding.UTF8);

Microsoft.CodeAnalysis.Compiler.Test.Resources (1)

ResourceLoader.cs (1)

67using (var streamReader = new StreamReader(stream, Encoding.UTF8, detectEncodingFromByteOrderMarks: true))

Microsoft.CodeAnalysis.CSharp (2)

Syntax\CSharpSyntaxTree.Dummy.cs (1)

46get { return Encoding.UTF8; }

Syntax\SyntaxFactory.cs (1)

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

Microsoft.CodeAnalysis.CSharp.CommandLine.UnitTests (8)

CommandLineTests.cs (7)

2307byte[] slContent = Encoding.UTF8.GetBytes(@"{ ""documents"" : {} }"); 2525var sourceStr = Encoding.UTF8.GetString(sourceBlob.Array, sourceBlob.Offset, sourceBlob.Count); 2544var content = File.ReadAllText(file, encoding ?? Encoding.UTF8); 7685var explicitManifestStream = new MemoryStream(Encoding.UTF8.GetBytes(explicitManifest)); 9066return new TestStream(backingStream: new MemoryStream(Encoding.UTF8.GetBytes(@" 9254var actual = new string(Encoding.UTF8.GetChars(bytes)); 14042context.AddSource("hint2", SourceText.From("class G2 { void F() {} }", Encoding.UTF8, checksumAlgorithm: SourceHashAlgorithm.Sha1));

src\Compilers\Test\Resources\Core\ResourceLoader.cs (1)

67using (var streamReader = new StreamReader(stream, Encoding.UTF8, detectEncodingFromByteOrderMarks: true))

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

Debugging\ProximityExpressionsGetterTests.cs (1)

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

PdbSourceDocument\AbstractPdbSourceDocumentTests.cs (1)

190var sourceText = SourceText.From(source, encoding: encoding ?? Encoding.UTF8);

PdbSourceDocument\ImplementationAssemblyLookupServiceTests.cs (17)

PdbSourceDocument\PdbSourceDocumentLoaderServiceTests.cs (2)

45var result = await service.LoadSourceDocumentAsync(path, sourceDocument, Encoding.UTF8, new TelemetryMessage(CancellationToken.None), useExtendedTimeout: false, CancellationToken.None); 73var result = await service.LoadSourceDocumentAsync(path, sourceDocument, Encoding.UTF8, new TelemetryMessage(CancellationToken.None), useExtendedTimeout: false, CancellationToken.None);

PdbSourceDocument\PdbSourceDocumentTests.cs (10)

327var sourceText = SourceText.From(metadataSource, encoding: Encoding.UTF8); 353var sourceText = SourceText.From(metadataSource, encoding: Encoding.UTF8); 385var sourceText = SourceText.From(metadataSource, Encoding.UTF8); 426var sourceText = SourceText.From(metadataSource, Encoding.UTF8); 455""", Encoding.UTF8); 629""", Encoding.UTF8), project, Location.OnDisk, Location.OnDisk, buildReferenceAssembly: false, windowsPdb: false); 658""", Encoding.UTF8); 775var sourceText = SourceText.From(source, Encoding.UTF8); 826var sourceText1 = SourceText.From(source1, Encoding.UTF8); 827var sourceText2 = SourceText.From(source2, Encoding.UTF8);

Microsoft.CodeAnalysis.CSharp.Emit.UnitTests (6)

Emit\CompilationEmitTests.cs (6)

290Encoding.UTF8.GetString(xmlDocBytes)); 336Encoding.UTF8.GetString(xmlDocBytes)); 390Encoding.UTF8.GetString(xmlDocBytes)); 446Encoding.UTF8.GetString(xmlDocBytes)); 499Encoding.UTF8.GetString(xmlDocBytes)); 548Encoding.UTF8.GetString(xmlDocBytes));

Microsoft.CodeAnalysis.CSharp.Emit2.UnitTests (16)

Emit\EditAndContinue\EditAndContinueTests.cs (3)

20502AFB1C33C5229BFF7EF739BA44DA795A2B68A49E06001C07C5B026CAA6C6322BB: {BitConverter.ToString(Encoding.UTF8.GetBytes("0123456789X"))}-00-00-00-00-00-00-00 20601ACE59E7D984CCEB2D860A056A3386344236CE5C42C978E26ECE3F35956DAC3AD: {BitConverter.ToString(Encoding.UTF8.GetBytes("0123456789X"))}-00 2076084D89877F0D4041EFB6BF91A16F0248F2FD573E6AF05C19F96BEDB9F882F7882: {BitConverter.ToString(Encoding.UTF8.GetBytes("0123456789"))}-00-00

PDB\CheckSumTest.cs (2)

34var tree1 = SyntaxFactory.ParseSyntaxTree(StringText.From(source1, Encoding.UTF8, SourceHashAlgorithm.Sha1), path: "sha1.cs"); 35var tree256 = SyntaxFactory.ParseSyntaxTree(StringText.From(source256, Encoding.UTF8, SourceHashAlgorithm.Sha256), path: "sha256.cs");

PDB\CSharpDeterministicBuildCompilationTests.cs (3)

109", filename: "a.cs", options: parseOptions, encoding: Encoding.UTF8); 169", filename: "a.cs", options: parseOptions, encoding: Encoding.UTF8); 233", filename: "a.cs", options: parseOptions, encoding: Encoding.UTF8);

PDB\PDBSourceLinkTests.cs (2)

43var sourceLinkBlob = Encoding.UTF8.GetBytes(@" 74var sourceLinkBlob = Encoding.UTF8.GetBytes(@"

PDB\PDBTests.cs (3)

48var tree4 = SyntaxFactory.ParseSyntaxTree("class D { }", encoding: Encoding.UTF8, path: "Baz.cs"); 104context.AddSource("hint2", SourceText.From("class G2 { void F() {} }", Encoding.UTF8, checksumAlgorithm: SourceHashAlgorithm.Sha256)); 12307var tree = SyntaxFactory.ParseSyntaxTree(source, encoding: Encoding.UTF8, path: "HIDDEN.cs");

PDB\PortablePdbTests.cs (2)

293var sourceLinkBlob = Encoding.UTF8.GetBytes(@" 335var sourceLinkBlob = Encoding.UTF8.GetBytes(@"

PDB\TypeDefinitionDocumentTests.cs (1)

463var trees = sources.Select((s, i) => SyntaxFactory.ParseSyntaxTree(s, path: $"{i + 1}.cs", encoding: Encoding.UTF8)).ToArray();

Microsoft.CodeAnalysis.CSharp.Emit3.UnitTests (18)

Attributes\AttributeTests_CallerInfoAttributes.cs (15)

Attributes\AttributeTests_MarshalAs.cs (2)

1039{ "CustomMarshaler6", new byte[] { 0x2c, 0x00, 0x00, 0x60 }.Append(Encoding.UTF8.GetBytes("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\0")) }, 1041{ "CustomMarshaler8", new byte[] { 0x2c, 0x00, 0x00, 0x59 }.Append(Encoding.UTF8.GetBytes("System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089\0")) },

Attributes\AttributeTests_Security.cs (1)

1488string hexFileContent = PermissionSetAttributeWithFileReference.ConvertToHex(new MemoryStream(Encoding.UTF8.GetBytes(text)));

Microsoft.CodeAnalysis.CSharp.Scripting.UnitTests (10)

ScriptTests.cs (10)

48var script = CSharpScript.Create(new MemoryStream(Encoding.UTF8.GetBytes("1 + 2")), ScriptOptions); 144var script = CSharpScript.Create(new MemoryStream(Encoding.UTF8.GetBytes("1 + 2")), ScriptOptions); 861var opts = ScriptOptions.WithEmitDebugInformation(true).WithFilePath("debug.csx").WithFileEncoding(Encoding.UTF8); 875var opts = ScriptOptions.WithEmitDebugInformation(false).WithFilePath("debug.csx").WithFileEncoding(Encoding.UTF8); 884return VerifyStackTraceAsync(() => CSharpScript.Create(new MemoryStream(Encoding.UTF8.GetBytes("throw new System.Exception();")), opts), line: 1, column: 1, filename: "debug.csx"); 891return VerifyStackTraceAsync(() => CSharpScript.Create(new MemoryStream(Encoding.UTF8.GetBytes("throw new System.Exception();")), opts)); 906var opts = ScriptOptions.WithEmitDebugInformation(true).WithFileEncoding(Encoding.UTF8); 920var opts = ScriptOptions.WithEmitDebugInformation(false).WithFileEncoding(Encoding.UTF8); 929return VerifyStackTraceAsync(() => CSharpScript.Create(new MemoryStream(Encoding.UTF8.GetBytes("throw new System.Exception();")), opts), line: 1, column: 1, filename: ""); 936return VerifyStackTraceAsync(() => CSharpScript.Create(new MemoryStream(Encoding.UTF8.GetBytes("throw new System.Exception();")), opts));

Microsoft.CodeAnalysis.CSharp.Semantic.UnitTests (34)

Semantics\TopLevelStatementsTests.cs (2)

8843var newText = SourceText.From(text2, Encoding.UTF8, SourceHashAlgorithms.Default); 8849var tree = CSharpSyntaxTree.Create(compilationUnit, TestOptions.RegularDefault, path: "", Encoding.UTF8, SourceHashAlgorithms.Default);

SourceGeneration\AdditionalSourcesCollectionTests.cs (18)

SourceGeneration\GeneratorDriverTests.cs (11)

SourceGeneration\SyntaxAwareGeneratorTests.cs (3)

420onExecute: (e) => { e.AddSource("test", SourceText.From("public class D{}", Encoding.UTF8)); } 510onExecute: (e) => { receiver = e.SyntaxReceiver; e.AddSource("test", SourceText.From("public class D{}", Encoding.UTF8)); } 2052onExecute: (e) => { e.AddSource("test", SourceText.From("public class D{}", Encoding.UTF8)); }

Microsoft.CodeAnalysis.CSharp.Symbol.UnitTests (4)

Compilation\CompilationAPITests.cs (2)

2263var appConfig = new MemoryStream(Encoding.UTF8.GetBytes( 2323var appConfig = new MemoryStream(Encoding.UTF8.GetBytes(

Symbols\CompilationCreationTests.cs (1)

2793new[] { SyntaxFactory.ParseSyntaxTree(@"#r ""bar""", TestOptions.Script, "a.csx", Encoding.UTF8) },

Symbols\CovariantReturnTests.cs (1)

451return comp.AddSyntaxTrees(CSharpSyntaxTree.ParseText(assignments, (CSharpParseOptions)comp.SyntaxTrees[0].Options, path: "assignments.cs", encoding: Encoding.UTF8));

Microsoft.CodeAnalysis.CSharp.Syntax.UnitTests (4)

Syntax\Mocks\MockCSharpSyntaxTree.cs (1)

29_sourceText = source ?? SourceText.From("", Encoding.UTF8, SourceHashAlgorithm.Sha256);

Syntax\SyntaxTreeTests.cs (3)

86SyntaxTreeFactoryKind.ParseText => CSharpSyntaxTree.ParseText(SourceText.From(source, Encoding.UTF8, SourceHashAlgorithm.Sha256), parseOptions), 87SyntaxTreeFactoryKind.Subclass => new MockCSharpSyntaxTree(root, SourceText.From(source, Encoding.UTF8, SourceHashAlgorithm.Sha256), parseOptions), 89SyntaxTreeFactoryKind.ParsedTreeWithPath => WithInitializedDirectives(CSharpSyntaxTree.Create(root, options: parseOptions, path: "old path", Encoding.UTF8)).WithFilePath("new path"),

Microsoft.CodeAnalysis.CSharp.Test.Utilities (2)

CSharpTestBase.cs (1)

2374string text = Encoding.UTF8.GetString(stream.ToArray());

CSharpTestSource.cs (1)

41var stringText = SourceText.From(text, encoding ?? Encoding.UTF8, checksumAlgorithm);

Microsoft.CodeAnalysis.CSharp.WinRT.UnitTests (2)

Metadata\WinMdDumpTest.cs (2)

468var expected = Encoding.UTF8.GetString(TestResources.WinRt.Windows_dump); 478var expected = Encoding.UTF8.GetString(TestResources.WinRt.WinMDPrefixing_dump);

Microsoft.CodeAnalysis.Debugging.Package (1)

CustomDebugInfoReader.cs (1)

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

Microsoft.CodeAnalysis.EditorFeatures (1)

Workspaces\EditorTextFactoryService.cs (1)

85return buffer.CurrentSnapshot.AsRoslynText(_textBufferCloneService, reader.CurrentEncoding ?? Encoding.UTF8, checksumAlgorithm);

Microsoft.CodeAnalysis.EditorFeatures.Text (2)

Extensions.cs (2)

96/// Note that this will return <see cref="Encoding.UTF8"/> if the <see cref="ITextBuffer"/> 104: Encoding.UTF8;

Microsoft.CodeAnalysis.EditorFeatures.UnitTests (6)

EditAndContinue\EditAndContinueLanguageServiceTests.cs (4)

357var sourceFile = dir.CreateFile("test.cs").WriteAllText(source1, Encoding.UTF8); 372loader: new WorkspaceFileTextLoader(workspace.Services.SolutionServices, sourceFile.Path, Encoding.UTF8), 384File.WriteAllText(sourceFile.Path, "class C1 { void M() { System.Console.WriteLine(\"b\"); } }", Encoding.UTF8); 391Text = SourceText.From("class C1 { void M() { System.Console.WriteLine(\"c\"); } }", Encoding.UTF8, SourceHashAlgorithm.Sha1)

Workspaces\TextFactoryTests.cs (2)

71.. Encoding.UTF8.GetPreamble(), 75expectedEncoding: Encoding.UTF8);

Microsoft.CodeAnalysis.ExpressionEvaluator.ExpressionCompiler (4)

CustomTypeInfo.cs (2)

150return new ReadOnlyCollection<byte>(Encoding.UTF8.GetBytes(str)); 157var str = Encoding.UTF8.GetString(array, 0, length);

PDB\MethodDebugInfo.Portable.cs (2)

243return Encoding.UTF8.GetString(bytes, 0, bytes.Length); 262return Encoding.UTF8.GetString(bytes, 0, bytes.Length);

Microsoft.CodeAnalysis.ExpressionEvaluator.ResultProvider (2)

src\ExpressionEvaluator\Core\Source\ExpressionCompiler\CustomTypeInfo.cs (2)

150return new ReadOnlyCollection<byte>(Encoding.UTF8.GetBytes(str)); 157var str = Encoding.UTF8.GetString(array, 0, length);

Microsoft.CodeAnalysis.ExpressionEvaluator.ResultProvider.Utilities (2)

src\ExpressionEvaluator\Core\Source\ExpressionCompiler\CustomTypeInfo.cs (2)

150return new ReadOnlyCollection<byte>(Encoding.UTF8.GetBytes(str)); 157var str = Encoding.UTF8.GetString(array, 0, length);

Microsoft.CodeAnalysis.Features (6)

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

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

EditAndContinue\TraceLog.cs (1)

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

MetadataAsSource\MetadataAsSourceGeneratedFileInfo.cs (1)

21public static Encoding Encoding => Encoding.UTF8;

PdbSourceDocument\PdbSourceDocumentMetadataAsSourceFileProvider.cs (1)

247var encoding = defaultEncoding ?? Encoding.UTF8;

src\Analyzers\Core\Analyzers\Helpers\DiagnosticHelper.cs (1)

231return Encoding.UTF8.GetString(jsonBytes, 0, jsonBytes.Length);

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

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

Microsoft.CodeAnalysis.Features.Test.Utilities (11)

EditAndContinue\ActiveStatementTestHelpers.cs (1)

42static (source, path) => SyntaxFactory.ParseSyntaxTree(SourceText.From(source, encoding: Encoding.UTF8, SourceHashAlgorithms.Default), path: path),

EditAndContinue\EditAndContinueWorkspaceTestBase.cs (4)

154=> projectDirectory?.CreateFile(fileName).WriteAllText(content, Encoding.UTF8).Path ?? Path.Combine(TempRoot.Root, fileName); 357encoding ??= Encoding.UTF8; 464=> SourceText.From(source, Encoding.UTF8, SourceHashAlgorithms.Default); 469return SourceText.From(stream, Encoding.UTF8, SourceHashAlgorithms.Default);

EditAndContinue\Extensions.cs (3)

91SourceText.From(source, Encoding.UTF8, SourceHashAlgorithms.Default), 102Assert.True(Encoding.UTF8.GetByteCount(projectName) <= 20, "Use shorter project names in tests"); 103return BlobContentId.FromHash(Encoding.UTF8.GetBytes(projectName.PadRight(20, '\0'))).Guid;

Snippets\AbstractSnippetProviderTests.cs (3)

44SourceText.From(markupBeforeCommit, Encoding.UTF8, SourceHashAlgorithms.Default), 51SourceText.From(editorconfig, Encoding.UTF8, SourceHashAlgorithms.Default), 132var document = project.AddDocument("TestDocument", SourceText.From(markup, Encoding.UTF8, SourceHashAlgorithms.Default));

Microsoft.CodeAnalysis.Features.UnitTests (59)

EditAndContinue\ActiveStatementsMapTests.cs (3)

120.AddDocument("doc", SourceText.From(source, Encoding.UTF8), filePath: "a.cs").Project.Solution; 177.AddDocument("doc", SourceText.From(source, Encoding.UTF8), filePath: "a.cs").Project.Solution; 230.AddDocument("doc", SourceText.From(source, Encoding.UTF8), filePath: "a.cs").Project.Solution;

EditAndContinue\EditAndContinueWorkspaceServiceTests.cs (48)

EditAndContinue\EditSessionActiveStatementsTests.cs (1)

81var text = SourceText.From(SourceMarkers.Clear(markedSources[i]), Encoding.UTF8);

EditAndContinue\EmitSolutionUpdateResultsTests.cs (1)

76AddDocument(sourcePath, SourceText.From("class C {}", Encoding.UTF8), filePath: Path.Combine(TempRoot.Root, sourcePath));

EditAndContinue\RemoteEditAndContinueServiceTests.cs (1)

84.AddDocument(documentId, "test.cs", SourceText.From("class C { }", Encoding.UTF8), filePath: "test.cs")

EditAndContinue\UnitTestingHotReloadServiceTests.cs (2)

27var sourceFileA = dir.CreateFile("A.cs").WriteAllText(source1, Encoding.UTF8); 43loader: new WorkspaceFileTextLoader(solution.Services, sourceFileA.Path, Encoding.UTF8),

EditAndContinue\WatchHotReloadServiceTests.cs (3)

47var sourceFileA = dir.CreateFile("A.cs").WriteAllText(source1, Encoding.UTF8); 62loader: new WorkspaceFileTextLoader(solution.Services, sourceFileA.Path, Encoding.UTF8), 181context.AddSource("generated.cs", SourceText.From("generated: " + additionalText, Encoding.UTF8, SourceHashAlgorithm.Sha256));

Microsoft.CodeAnalysis.LanguageServer (1)

FileBasedPrograms\VirtualProjectXmlProvider.cs (1)

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

Microsoft.CodeAnalysis.LanguageServer.Protocol (2)

Features\Diagnostics\DiagnosticDataExtensions.cs (1)

40using var stream = new MemoryStream(Encoding.UTF8.GetBytes(indicesProperty));

Handler\DocumentChanges\DidOpenHandler.cs (1)

36var sourceText = SourceText.From(request.TextDocument.Text, System.Text.Encoding.UTF8, SourceHashAlgorithms.OpenDocumentChecksumAlgorithm);

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

Workspaces\LspWorkspaceManagerTests.cs (3)

85await testLspServer.TestWorkspace.ChangeDocumentAsync(firstDocument.Id, SourceText.From($"Some more text{markupOne}", System.Text.Encoding.UTF8, SourceHashAlgorithms.Default)); 119await testLspServer.TestWorkspace.ChangeDocumentAsync(secondDocument.Id, SourceText.From("Two is now three!", System.Text.Encoding.UTF8, SourceHashAlgorithms.Default)); 221var newSolution = testLspServer.TestWorkspace.CurrentSolution.AddDocument(newDocumentId, "NewDoc.cs", SourceText.From("New Doc", System.Text.Encoding.UTF8, SourceHashAlgorithms.Default), filePath: @"C:\NewDoc.cs");

Microsoft.CodeAnalysis.LanguageServer.UnitTests (1)

VirtualProjectXmlProviderTests.cs (1)

63globalJsonFile.WriteAllBytes(Encoding.UTF8.GetBytes("""

Microsoft.CodeAnalysis.PerformanceSensitiveAnalyzers (8)

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

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

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

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

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

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

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

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

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

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

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

Microsoft.CodeAnalysis.PublicApiAnalyzers (8)

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

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

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

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

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

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

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

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

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

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

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

Microsoft.CodeAnalysis.Rebuild (1)

CompilationOptionsReader.cs (1)

119? Encoding.UTF8

Microsoft.CodeAnalysis.Rebuild.UnitTests (8)

BasicDeterministicKeyBuilderTests.cs (3)

32SourceText.From(content, checksumAlgorithm: hashAlgorithm, encoding: Encoding.UTF8), 83var additionalText = new TestAdditionalText(content, Encoding.UTF8, path: "file.txt", HashAlgorithm); 318var json = Encoding.UTF8.GetString(keyFile.Contents.ToArray());

CSharpDeterministicKeyBuilderTests.cs (3)

32encoding: Encoding.UTF8, 192var additionalText = new TestAdditionalText(content, Encoding.UTF8, path: "file.txt", HashAlgorithm); 502var json = Encoding.UTF8.GetString(keyFile.Contents.ToArray());

OptionRoundTripTests.cs (1)

53encoding: Encoding.UTF8,

RoundTripUtil.cs (1)

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

Microsoft.CodeAnalysis.ResxSourceGenerator (12)

AbstractResxGenerator.cs (4)

209var errorText = SourceText.From(text, Encoding.UTF8, SourceHashAlgorithm.Sha256); 323OutputText = SourceText.From("", Encoding.UTF8); 349OutputText = SourceText.From(result, Encoding.UTF8, SourceHashAlgorithm.Sha256); 742OutputText = SourceText.From(result, Encoding.UTF8, SourceHashAlgorithm.Sha256);

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

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

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

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

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

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

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

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

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

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

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

Microsoft.CodeAnalysis.ResxSourceGenerator.UnitTests (4)

Verifiers\CSharpSourceGeneratorVerifier`1+Test.cs (2)

122using var reader = new StreamReader(resourceStream, Encoding.UTF8, detectEncodingFromByteOrderMarks: true, bufferSize: 4096, leaveOpen: true); 124TestState.GeneratedSources.Add((typeof(TSourceGenerator), name, SourceText.From(reader.ReadToEnd(), Encoding.UTF8, SourceHashAlgorithm.Sha256)));

Verifiers\VisualBasicSourceGeneratorVerifier`1+Test.cs (2)

107using var reader = new StreamReader(resourceStream, Encoding.UTF8, detectEncodingFromByteOrderMarks: true, bufferSize: 4096, leaveOpen: true); 109TestState.GeneratedSources.Add((typeof(VisualBasicResxGenerator), name, SourceText.From(reader.ReadToEnd(), Encoding.UTF8, SourceHashAlgorithm.Sha256)));

Microsoft.CodeAnalysis.Scripting.TestUtilities (2)

TestConsoleIO.cs (2)

58public override Encoding Encoding => Encoding.UTF8; 108public override Encoding Encoding => Encoding.UTF8;

Microsoft.CodeAnalysis.SemanticSearch.Extensions (3)

ProjectModel.cs (3)

114return File.ReadAllText(FilePath, Encoding.UTF8); 133Encoding = Encoding.UTF8, 143using var reader = new StreamReader(stream, Encoding.UTF8);

Microsoft.CodeAnalysis.Test.Utilities (11)

Metadata\MetadataReaderUtils.cs (1)

238builder.AddRange(System.Text.Encoding.UTF8.GetBytes(str));

Mocks\TestSourceReferenceResolver.cs (1)

52return new MemoryStream((data is string) ? Encoding.UTF8.GetBytes((string)data) : (byte[])data);

ResourceLoader.cs (1)

59using (var streamReader = new StreamReader(stream, Encoding.UTF8, detectEncodingFromByteOrderMarks: true))

SourceGeneration\TestGenerators.cs (4)

40context.AddSource(hintName, SourceText.From(content, Encoding.UTF8)); 98: SourceText.From(source, Encoding.UTF8))); 109: SourceText.From(source, Encoding.UTF8))); 145_content = SourceText.From(content, Encoding.UTF8);

Syntax\SourceUtilities.cs (1)

27public override Encoding Encoding => Encoding.UTF8;

TempFiles\TempFile.cs (1)

94return WriteAllTextAsync(content, Encoding.UTF8);

TestableFile.cs (1)

70Contents.AddRange(Encoding.UTF8.GetBytes(contents));

Win32Res.cs (1)

75encoding = Encoding.UTF8;

Microsoft.CodeAnalysis.TestAnalyzerReference (3)

HelloWorldGenerator.cs (3)

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

Microsoft.CodeAnalysis.UnitTests (32)

Diagnostics\SarifErrorLoggerTests.cs (3)

47string actual = Encoding.UTF8.GetString(stream.ToArray()); 87string actual = Encoding.UTF8.GetString(stream.ToArray()); 130Encoding.UTF8.GetString(buffer, 0, buffer.Length),

EmbeddedTextTests.cs (11)

42Assert.Throws<ArgumentException>("text", () => EmbeddedText.FromSource("path", SourceText.From(new byte[0], 0, Encoding.UTF8, canBeEmbedded: false))); 43Assert.Throws<ArgumentException>("text", () => EmbeddedText.FromSource("path", SourceText.From(new MemoryStream(new byte[0]), Encoding.UTF8, canBeEmbedded: false))); 116var bytes = Encoding.UTF8.GetBytes(SmallSource); 130var bytes = Encoding.UTF8.GetBytes(SmallSource); 145var source = SourceText.From(SmallSource, Encoding.UTF8, SourceHashAlgorithm.Sha1); 152AssertEx.Equal(Encoding.UTF8.GetPreamble().Concat(Encoding.UTF8.GetBytes(SmallSource)), text.Blob.Skip(4)); 200var expected = SourceText.From(SmallSource, Encoding.UTF8, SourceHashAlgorithm.Sha1); 203var actual = SourceText.From(new StringReader(SmallSource), SmallSource.Length, Encoding.UTF8, SourceHashAlgorithm.Sha1); 215var expected = SourceText.From(LargeSource, Encoding.UTF8, SourceHashAlgorithm.Sha1); 218var actual = SourceText.From(new StringReader(LargeSource), LargeSource.Length, Encoding.UTF8, SourceHashAlgorithm.Sha1);

Text\LargeTextTests.cs (4)

22using (StreamWriter sw = new StreamWriter(stream, encoding ?? Encoding.UTF8, bufferSize: 1024, leaveOpen: true)) 33return LargeText.Decode(stream, encoding ?? Encoding.UTF8, SourceHashAlgorithm.Sha1, throwIfBinaryDetected: true, canBeEmbedded: false); 38return LargeText.Decode(reader, length, encoding ?? Encoding.UTF8, SourceHashAlgorithm.Sha1); 115using (StreamWriter sw = new StreamWriter(stream, Encoding.UTF8, bufferSize: 1024, leaveOpen: true))

Text\SourceTextTests.cs (3)

22private static readonly Encoding s_utf8 = Encoding.UTF8; 332var encoding = Encoding.UTF8; 412TestTryReadByteOrderMark(expectedEncoding: Encoding.UTF8, expectedPreambleLength: 3, data: new byte[] { 0xef, 0xBB, 0xBF });

Text\StringTextDecodingTests.cs (2)

134var data = CreateMemoryStreamBasedEncodedText("", Encoding.UTF8, readEncodingOpt: null, algorithm: SourceHashAlgorithm.Sha256); 197Assert.Equal(Encoding.UTF8.EncodingName, sourceText.Encoding.EncodingName);

Text\StringTextTest.cs (8)

46var data = SourceText.From("goo", Encoding.UTF8); 69Assert.Throws<ArgumentNullException>(() => SourceText.From((string)null, Encoding.UTF8)); 75Assert.Throws<ArgumentNullException>(() => SourceText.From((Stream)null, Encoding.UTF8)); 76Assert.Throws<ArgumentException>(() => SourceText.From(new TestStream(canRead: false, canSeek: true), Encoding.UTF8)); 77Assert.Throws<NotImplementedException>(() => SourceText.From(new TestStream(canRead: true, canSeek: false), Encoding.UTF8)); 83var data = SourceText.From(string.Empty, Encoding.UTF8); 224var data = SourceText.From("The quick brown fox jumps over the lazy dog", Encoding.UTF8); 259var bytes = Encoding.UTF8.GetBytes("\u1234");

Text\TextChangeTests.cs (1)

613return new LargeText(ImmutableArray.Create(chunks), Encoding.UTF8, default(ImmutableArray<byte>), SourceHashAlgorithms.Default, default(ImmutableArray<byte>));

Microsoft.CodeAnalysis.VisualBasic (4)

Symbols\EmbeddedSymbols\EmbeddedSymbolManager.vb (1)

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

Symbols\Source\SynthesizedMyGroupCollectionPropertyAccessorSymbol.vb (1)

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

Syntax\SyntaxNodeFactories.vb (1)

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

Syntax\VisualBasicSyntaxTree.DummySyntaxTree.vb (1)

39Return Encoding.UTF8

Microsoft.CodeAnalysis.Workspaces (13)

Log\AnalyzerNameForTelemetry.cs (1)

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

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

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

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

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

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

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

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

Storage\SQLite\Interop\NativeMethods.cs (1)

143/// <paramref name="val"><see cref="Encoding.UTF8"/> encoded bytes of a text value. Span

Storage\SQLite\v2\Interop\SqlConnection.cs (2)

50var length = Encoding.UTF8.GetByteCount(value); 54var wrote = Encoding.UTF8.GetBytes(value, 0, value.Length, byteArray, 0);

Storage\SQLite\v2\Interop\SqlStatement.cs (2)

78var utf8ByteCount = Encoding.UTF8.GetByteCount(value); 83Contract.ThrowIfFalse(Encoding.UTF8.GetBytes(value.AsSpan(), bytes) == utf8ByteCount);

Workspace\Solution\TextLoader.cs (1)

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

Microsoft.CodeAnalysis.Workspaces.MSBuild (1)

MSBuild\MSBuildWorkspace.cs (1)

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

Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost (2)

MSBuild\ProjectFile\ProjectFileLoader.cs (1)

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

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

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

Microsoft.CodeAnalysis.Workspaces.Test.Utilities (2)

GenerateFileForEachAdditionalFileWithContentsCommented.cs (1)

35return SourceText.From(generatedText.ToString(), encoding: Encoding.UTF8);

Workspaces\TestHostDocument.cs (1)

190=> Task.FromResult(TextAndVersion.Create(SourceText.From(_text, encoding: Encoding.UTF8, options.ChecksumAlgorithm), VersionStamp.Create(), _hostDocument.FilePath));

Microsoft.CodeAnalysis.Workspaces.UnitTests (34)

SolutionTests\SolutionTests.cs (32)

SolutionTests\SolutionWithSourceGeneratorTests.cs (1)

617var differentOpenTextContainer = SourceText.From("// StaticContent", Encoding.UTF8).Container;

UtilityTest\XmlDocumentationProviderTests.cs (1)

21var documentationProvider = XmlDocumentationProvider.CreateFromBytes(Encoding.UTF8.GetBytes("""

Microsoft.Data.Analysis (6)

DataFrame.IO.cs (1)

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

DataFrameColumns\ArrowStringDataFrameColumn.cs (5)

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

Microsoft.Data.Analysis.Tests (1)

ArrowStringColumnTests.cs (1)

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

Microsoft.DotNet.Arcade.Sdk (6)

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)

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

src\ValidateLicense.cs (2)

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

Microsoft.DotNet.Baselines.Tasks (1)

PRCreator.cs (1)

210content = Encoding.UTF8.GetString(Convert.FromBase64String(originalBlob.Content));

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

src\common\GeneralUtils.cs (2)

273StandardOutputEncoding = Encoding.UTF8, 274StandardErrorEncoding = Encoding.UTF8

src\CreateAzureDevOpsFeed.cs (1)

149createFeedMessage.Content = new StringContent(createBody, Encoding.UTF8, "application/json");

src\model\SetupTargetFeedConfigV3.cs (1)

86return Encoding.UTF8.GetString(Convert.FromBase64String(value));

src\model\SetupTargetFeedConfigV4.cs (1)

85return Encoding.UTF8.GetString(Convert.FromBase64String(value));

Microsoft.DotNet.Build.Tasks.Installers (8)

src\GenerateGuidFromName.cs (1)

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

src\RpmBuilder.cs (1)

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

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

GenerateNuSpec.cs (2)

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

Microsoft.DotNet.Build.Tasks.VisualStudio (8)

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

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

Msi\MsiPayloadPackageProject.wix.cs (1)

55Utils.StringReplace(msiCsproj, ReplacementTokens, Encoding.UTF8);

Swix\MsiSwixProject.wix.cs (1)

111Utils.StringReplace(swixProj, ReplacementTokens, Encoding.UTF8);

Swix\SwixProjectBase.cs (1)

88Utils.StringReplace(path, ReplacementTokens, Encoding.UTF8);

Utils.cs (1)

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

Microsoft.DotNet.Deployment.Tasks.Links (1)

src\AkaMSLinksManager.cs (1)

276requestMessage.Content = new StringContent(newOrUpdatedLinksJson, Encoding.UTF8, "application/json");

Microsoft.DotNet.Helix.Client (7)

generated-code\Aggregate.cs (1)

1260_req.Content = RequestContent.Create(Encoding.UTF8.GetBytes(Client.Serialize(body)));

generated-code\Analysis.cs (1)

114_req.Content = RequestContent.Create(Encoding.UTF8.GetBytes(Client.Serialize(body)));

generated-code\Job.cs (1)

135_req.Content = RequestContent.Create(Encoding.UTF8.GetBytes(Client.Serialize(body)));

generated-code\Machine.cs (1)

90_req.Content = RequestContent.Create(Encoding.UTF8.GetBytes(Client.Serialize(body)));

generated-code\Storage.cs (2)

159_req.Content = RequestContent.Create(Encoding.UTF8.GetBytes(Client.Serialize(body))); 245_req.Content = RequestContent.Create(Encoding.UTF8.GetBytes(Client.Serialize(body)));

generated-code\Telemetry.cs (1)

132_req.Content = RequestContent.Create(Encoding.UTF8.GetBytes(Client.Serialize(body)));

Microsoft.DotNet.Helix.JobSender (2)

Payloads\SingleFilePayload.cs (1)

19: this(name, content, Encoding.UTF8)

StorageHelpers\ContainerBase.cs (1)

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

Microsoft.DotNet.Helix.Sdk (4)

AzureDevOpsTask.cs (1)

67Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(Encoding.UTF8.GetBytes("unused:" + AccessToken))),

CreateFailedTestsForFailedWorkItems.cs (1)

63Encoding.UTF8,

StartAzurePipelinesTestRun.cs (1)

48Encoding.UTF8,

StopAzurePipelinesTestRun.cs (1)

35Encoding.UTF8,

Microsoft.DotNet.Internal.SymbolHelper (2)

SymbolPromotionHelper.cs (2)

152Content = new StringContent(payload.ToString(), Encoding.UTF8, "application/json") 269Content = new StringContent(extensionPayload.ToString(), Encoding.UTF8, "application/json")

Microsoft.DotNet.SignCheckLibrary (2)

Utils.cs (1)

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

Verification\Jar\JarManifestFileBase.cs (1)

102using (var manifestStreamReader = new StreamReader(manifestStream, Encoding.UTF8))

Microsoft.Extensions.AI (2)

ChatCompletion\ChatResponse{T}.cs (2)

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

Microsoft.Extensions.AI.Abstractions (1)

Contents\DataUriParser.cs (1)

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

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

Formats\Html\HtmlReportWriter.cs (1)

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

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

ResponseCacheTester.cs (2)

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

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

PromptBasedFunctionCallingChatClient.cs (1)

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

VerbatimHttpHandler.cs (1)

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

VerbatimMultiPartHttpHandler.cs (2)

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

Microsoft.Extensions.AI.OpenAI (4)

src\Shared\ServerSentEvents\Helpers.cs (3)

65int maxByteCount = Encoding.UTF8.GetMaxByteCount(value.Length); 70bytesWritten = Encoding.UTF8.GetBytes(value, buffer); 116return Encoding.UTF8.GetString(bytes);

src\Shared\ServerSentEvents\SseParser.cs (1)

27/// that decodes the data of each event using <see cref="Encoding.UTF8"/>'s GetString method.

Microsoft.Extensions.Caching.Abstractions (4)

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

Microsoft.Extensions.Caching.Hybrid (4)

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

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

SerializerTests.cs (1)

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

Microsoft.Extensions.Caching.SqlServer.Tests (20)

SqlServerCacheWithDatabaseTest.cs (20)

Microsoft.Extensions.Caching.StackExchangeRedis (1)

RedisCache.cs (1)

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

Microsoft.Extensions.Caching.StackExchangeRedis.Tests (1)

RedisCacheSetAndRemoveTests.cs (1)

176static string Hex(string value) => Hex(Encoding.UTF8.GetBytes(value));

Microsoft.Extensions.Configuration.KeyPerFile.Tests (1)

KeyPerFileTests.cs (1)

544: new MemoryStream(Encoding.UTF8.GetBytes(_contents));

Microsoft.Extensions.FileProviders.Embedded.Tests (1)

TestAssembly.cs (1)

19using (var writer = new StreamWriter(ManifestStream, Encoding.UTF8, 1024, leaveOpen: true))

Microsoft.Extensions.Hosting.Systemd (2)

ServiceState.cs (2)

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

Microsoft.Extensions.Http.Diagnostics (2)

Logging\Internal\HttpRequestBodyReader.cs (1)

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

Logging\Internal\HttpResponseBodyReader.cs (1)

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

Microsoft.Extensions.Http.Diagnostics.Tests (49)

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

Logging\HttpResponseBodyReaderTest.cs (6)

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

Microsoft.Extensions.Http.Resilience.Tests (1)

Resilience\RequestMessageSnapshotTests.cs (1)

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

Microsoft.Extensions.Logging.Console (2)

JsonConsoleFormatter.cs (2)

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

Microsoft.Extensions.Logging.EventSource (1)

EventSourceLogger.cs (1)

275return Encoding.UTF8.GetString(buffer.Array!, buffer.Offset, buffer.Count);

Microsoft.Extensions.Logging.Generators (1)

LoggerMessageGenerator.Roslyn4.0.cs (1)

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

Microsoft.Extensions.Options.SourceGeneration (1)

Generator.cs (1)

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

Microsoft.Extensions.SecretManager.Tools.Tests (5)

SecretManagerTests.cs (4)

219File.WriteAllText(secretsFile, @"{ ""AzureAd"": { ""ClientSecret"": ""abcdéƒ©˙î""} }", Encoding.UTF8); 232File.WriteAllText(secretsFile, @"{ ""AzureAd"": { ""ClientSecret"": ""abcdéƒ©˙î""} }", Encoding.UTF8); 248File.WriteAllText(secretsFile, @"{ ""AzureAd"": { ""ClientSecret"": ""abcdéƒ©˙î""} }", Encoding.UTF8); 254var fileContents = File.ReadAllText(secretsFile, Encoding.UTF8);

TemporaryFileProvider.cs (1)

21File.WriteAllText(Path.Combine(Root, filename), contents, Encoding.UTF8);

Microsoft.Extensions.ServiceDiscovery.Dns.Tests (1)

Resolver\LoopbackDnsServer.cs (1)

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

Microsoft.Extensions.ServiceDiscovery.Dns.Tests.Fuzzing (1)

Fuzzers\WriteDomainNameRoundTripFuzzer.cs (1)

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

Microsoft.Extensions.Telemetry.Tests (1)

Latency\Internal\LatencyConsoleExporterTests.cs (1)

160public override Encoding Encoding => Encoding.UTF8;

Microsoft.Extensions.Validation.GeneratorTests (2)

ValidationsGeneratorTestBase.cs (2)

137var encoding = text.Encoding ?? Encoding.UTF8; 577var stream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(requestData));

Microsoft.Extensions.Validation.ValidationsGenerator (1)

Emitters\ValidationsGenerator.Emitter.cs (1)

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

Microsoft.Gen.ComplianceReports (1)

ComplianceReportsGenerator.cs (1)

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

Microsoft.Gen.Logging (1)

LoggingGenerator.cs (1)

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

Microsoft.Gen.MetadataExtractor (3)

MetadataReportsGenerator.cs (1)

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

src\Generators\Microsoft.Gen.ComplianceReports\ComplianceReportsGenerator.cs (1)

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

src\Generators\Microsoft.Gen.MetricsReports\MetricsReportsGenerator.cs (1)

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

Microsoft.Gen.Metrics (2)

MetricsGenerator.cs (2)

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

Microsoft.Gen.MetricsReports (1)

MetricsReportsGenerator.cs (1)

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

Microsoft.JSInterop (3)

Infrastructure\DotNetDispatcher.cs (3)

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

Microsoft.JSInterop.Tests (8)

JSRuntimeTest.cs (8)

Microsoft.Maui (2)

Handlers\HybridWebView\HybridWebViewHandler.cs (1)

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

Services\Crc64HashAlgorithm.cs (1)

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

Microsoft.Maui.Controls (1)

Internals\ImageParser.cs (1)

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

Microsoft.Maui.Controls.SourceGen (4)

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

Microsoft.Maui.Graphics (2)

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

Microsoft.ML.AutoML.SourceGenerator (3)

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

Microsoft.ML.AutoML.Tests (1)

TextFileSampleTests.cs (1)

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

Microsoft.ML.Core (8)

Data\ModelLoadContext.cs (1)

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

Data\ModelLoading.cs (2)

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

Data\ModelSaveContext.cs (2)

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

Data\ModelSaving.cs (1)

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

Utilities\TextReaderStream.cs (2)

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

Microsoft.ML.Data (9)

Commands\SavePredictorCommand.cs (1)

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

DataLoadSave\Binary\BinaryLoader.cs (2)

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

DataLoadSave\Binary\BinarySaver.cs (3)

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

DataLoadSave\Binary\CodecFactory.cs (2)

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

DataLoadSave\Transpose\TransposeSaver.cs (1)

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

Microsoft.ML.OnnxConverter (4)

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

Microsoft.ML.OnnxTransformer (1)

OnnxTransform.cs (1)

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

Microsoft.ML.TestFramework (1)

BytesStreamSource.cs (1)

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

Microsoft.ML.Tokenizers (38)

Model\BPETokenizer.cs (3)

1319int destinationMaxSize = Encoding.UTF8.GetMaxByteCount(text.Length); 1432int destinationMaxSize = Encoding.UTF8.GetMaxByteCount(text.Length); 1512int 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)

280int len = Encoding.UTF8.GetMaxCharCount(bytesCount); 618int 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)

196if (Encoding.UTF8.GetMaxCharCount(normalizationSpan.Length) > normalizedUtf16Span.Length) 294Debug.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)

SentencepieceModel.cs (5)

1399private readonly static string UnkPieceDefaultValue = global::System.Text.Encoding.UTF8.GetString(global::System.Convert.FromBase64String("PHVuaz4="), 0, 5); 1425private readonly static string BosPieceDefaultValue = global::System.Text.Encoding.UTF8.GetString(global::System.Convert.FromBase64String("PHM+"), 0, 3); 1451private readonly static string EosPieceDefaultValue = global::System.Text.Encoding.UTF8.GetString(global::System.Convert.FromBase64String("PC9zPg=="), 0, 4); 1477private readonly static string PadPieceDefaultValue = global::System.Text.Encoding.UTF8.GetString(global::System.Convert.FromBase64String("PHBhZD4="), 0, 5); 1503private readonly static string UnkSurfaceDefaultValue = global::System.Text.Encoding.UTF8.GetString(global::System.Convert.FromBase64String("IOKBhyA="), 0, 5);

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.netstandard.cs (5)

76return Encoding.UTF8.GetBytes(sourcePtr, source.Length, destPtr, destination.Length); 85if (Encoding.UTF8.GetByteCount(sourcePtr, source.Length) <= destination.Length) 87bytesWritten = Encoding.UTF8.GetBytes(sourcePtr, source.Length, destPtr, destination.Length); 100return Encoding.UTF8.GetString(sourcePtr, utf8Bytes.Length); 109return Encoding.UTF8.GetChars(bytesPtr, bytes.Length, charsPtr, chars.Length);

Utils\OrdinalUtf8StringComparer.cs (2)

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

Microsoft.ML.Tokenizers.Tests (13)

BpeTests.cs (2)

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

DoubleArrayTrieTest.cs (2)

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

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

Microsoft.Net.Http.Headers (3)

ContentDispositionHeaderValue.cs (3)

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

Microsoft.VisualBasic.Core (3)

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

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

Microsoft.VisualBasic.Forms.Tests (3)

System\Windows\Forms\FileLogTraceListenerTests.vb (1)

68listener.Encoding.Should.Be(Encoding.UTF8)

System\Windows\Forms\FileSystemProxyTests.vb (2)

391_fileSystem.WriteAllText(fileA, "A", append:=False, Encoding.UTF8) 392Dim text As String = _fileSystem.ReadAllText(fileA, Encoding.UTF8)

Microsoft.VisualStudio.LanguageServices (3)

Implementation\AbstractEditorFactory.cs (1)

370using var textWriter = new StreamWriter(filePath, append: false, encoding: formattedText.Encoding ?? Encoding.UTF8);

ProjectSystem\VisualStudioWorkspaceImpl.cs (2)

917using var writer = new StreamWriter(documentInfo.FilePath, append: false, encoding: text.Encoding ?? Encoding.UTF8); 961using var writer = new StreamWriter(filePath, append: false, encoding: initialText.Encoding ?? Encoding.UTF8);

Microsoft.VisualStudio.LanguageServices.CSharp (1)

SemanticSearch\SemanticSearchToolWindowImpl.cs (1)

480File.WriteAllText(filePath, newContent, Encoding.UTF8);

Microsoft.VisualStudio.LanguageServices.CSharp.UnitTests (1)

PersistentStorage\AbstractPersistentStorageTests.cs (1)

41private readonly Encoding _encoding = Encoding.UTF8;

Microsoft.VisualStudio.LanguageServices.Implementation (2)

Options\AbstractOptionPreviewViewModel.cs (2)

137var document = project.AddDocument("document", SourceText.From(text, Encoding.UTF8)); 144var textBuffer = _textBufferCloneService.Clone(SourceText.From(formatted.ToFullString(), Encoding.UTF8), _contentType);

PlaintextApp (1)

Startup.cs (1)

19private static readonly byte[] _helloWorldBytes = Encoding.UTF8.GetBytes("Hello, World!");

PresentationBuildTasks (1)

Microsoft\Build\Tasks\Windows\UpdateManifestForBrowserApplication.cs (1)

111manifestWriter = new XmlTextWriter(appManifestFile, System.Text.Encoding.UTF8)

PresentationFramework (3)

MS\Internal\WindowsRuntime\Generated\WinRT\GuidGenerator.cs (1)

137var data = wrt_pinterface_namespace.ToByteArray().Concat(UTF8Encoding.UTF8.GetBytes(sig)).ToArray();

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

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

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

43!encoding.Equals(Encoding.UTF8.WebName, StringComparison.OrdinalIgnoreCase))

RazorBuildWebSite (1)

UpdateableFileProvider.cs (1)

102return new MemoryStream(Encoding.UTF8.GetBytes(_content));

ReachFramework (7)

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

Replay (2)

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

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

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

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

Roslyn.Diagnostics.Analyzers (8)

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

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

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

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

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

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

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

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

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

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

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

Roslyn.Test.PdbUtilities (4)

Reader\PdbValidation.cs (1)

589Assert.Equal(Encoding.UTF8.GetByteCount(pdbPath) + 1, paddedPathLength);

Reader\Token2SourceLineExporter.cs (3)

257value = Encoding.UTF8.GetString(_buffer, _offset, len); 268value = Encoding.UTF8.GetString(_buffer, _offset, len); 1132Encoding = Encoding.UTF8,

Roslyn.VisualStudio.Next.UnitTests (9)

Remote\SnapshotSerializationTests.cs (2)

609var sourceText = SourceText.From("Hello", Encoding.UTF8); 750private readonly Encoding _real = Encoding.UTF8;

Services\ServiceHubServicesTests.cs (7)

515=> SourceText.From(content, encoding ?? Encoding.UTF8, checksumAlgorithm); 595[("SG.cs", CreateText("X", Encoding.UTF8))]); 600[("SG.cs", CreateText("X", Encoding.UTF8, checksumAlgorithm: SourceHashAlgorithm.Sha1))], 601[("SG.cs", CreateText("X", Encoding.UTF8, checksumAlgorithm: SourceHashAlgorithm.Sha256))]); 722return ImmutableArray.Create(("hint", SourceText.From($"// generated document {callCount}", Encoding.UTF8))); 806return ImmutableArray.Create(("hint", SourceText.From($"// generated document {callCount}", Encoding.UTF8))); 861return ImmutableArray.Create(("hint", SourceText.From($"// generated document {callCount}", Encoding.UTF8)));

RoutingSandbox (4)

HelloExtension\HelloMiddleware.cs (2)

21payload.AddRange(Encoding.UTF8.GetBytes("Hello")); 25payload.AddRange(Encoding.UTF8.GetBytes(_helloOptions.Greeter));

UseEndpointRoutingStartup.cs (2)

12private static readonly byte[] _plainTextPayload = Encoding.UTF8.GetBytes("Plain text!"); 68using (var writer = new StreamWriter(httpContext.Response.Body, Encoding.UTF8, 1024, leaveOpen: true))

RoutingWebSite (3)

HelloExtension\HelloMiddleware.cs (2)

21payload.AddRange(Encoding.UTF8.GetBytes("Hello")); 25payload.AddRange(Encoding.UTF8.GetBytes(_helloOptions.Greeter));

UseEndpointRoutingStartup.cs (1)

10private static readonly byte[] _plainTextPayload = Encoding.UTF8.GetBytes("Plain text!");

Security.TransportSecurity.IntegrationTests (8)

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

SecurityWebSite (1)

BearerAuth.cs (1)

15Key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(new string('a', 128)));

SemanticSearch.BuildTask (2)

GenerateFilteredReferenceAssembliesTask.cs (2)

167oldContent = File.ReadAllText(outputFilePath, Encoding.UTF8); 191File.WriteAllText(outputFilePath, newContent, Encoding.UTF8);

ServiceBusWorker (1)

Consumer.cs (1)

20logger.LogInformation("Received message: {Message}", Encoding.UTF8.GetString(args.Message.Body));

Shared (4)

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.

SignalRSamples (3)

ConnectionHandlers\MessagesConnectionHandler.cs (3)

35var text = Encoding.UTF8.GetString(buffer.ToArray()); 37await Broadcast(Encoding.UTF8.GetBytes(text)); 60return Broadcast(Encoding.UTF8.GetBytes(text));

SocialWeather (2)

Pipe\PipeWeatherStreamFormatter.cs (2)

55var utf8 = Encoding.UTF8; 57var convertedBytes = Encoding.Convert(Encoding.UTF8, Encoding.ASCII, encodedBytes);

System.CodeDom (7)

Microsoft\CSharp\CSharpCodeGenerator.cs (2)

3024using (StreamWriter sw = new StreamWriter(fs, Encoding.UTF8)) 3059using (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.TypeConverter (2)

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

System\Configuration\BaseConfigurationRecord.cs (1)

3705StreamEncoding = Encoding.UTF8;

System\Configuration\ImplicitMachineConfigHost.cs (1)

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

System.Console (3)

System\ConsolePal.Unix.cs (3)

1125data = stackalloc byte[Encoding.UTF8.GetMaxByteCount(value.Length)]; 1126int bytesToWrite = Encoding.UTF8.GetBytes(value, data); 1131data = Encoding.UTF8.GetBytes(value);

System.Diagnostics.Process (7)

src\libraries\Common\src\Interop\Linux\procfs\Interop.ProcFsStat.TryReadStatusFile.cs (1)

155contents = Encoding.UTF8.GetString(bytes, 0, count);

src\libraries\Common\src\Interop\Unix\System.Native\Interop.ForkAndExecProcess.cs (2)

67int byteLength = Encoding.UTF8.GetByteCount(str); 70int bytesWritten = Encoding.UTF8.GetBytes(str, new Span<byte>(arrPtr[i], byteLength));

src\libraries\Common\src\Interop\Unix\System.Native\Interop.ReadLink.cs (1)

57return Encoding.UTF8.GetString(spanBuffer.Slice(0, resultLength));

src\libraries\Common\src\System\Text\ValueUtf8Converter.cs (2)

26int maxSize = checked(Encoding.UTF8.GetMaxByteCount(value.Length) + 1); 35int byteCount = Encoding.UTF8.GetBytes(value, _bytes);

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

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

System.Formats.Tar (15)

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

760key = Encoding.UTF8.GetString(keySlice); 761value = Encoding.UTF8.GetString(valueSlice);

System\Formats\Tar\TarHeader.Write.cs (12)

System\Formats\Tar\TarHelpers.cs (1)

277return Encoding.UTF8.GetString(buffer);

System.IO.Compression (4)

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

211get => (EntryNameAndCommentEncoding ?? Encoding.UTF8).GetString(_archiveComment);

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

380? Encoding.UTF8 381: _archive?.EntryNameAndCommentEncoding ?? Encoding.UTF8;

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

29return Encoding.UTF8;

System.IO.FileSystem.Watcher (1)

System\IO\FileSystemWatcher.Linux.cs (1)

879Encoding.UTF8.GetString(_buffer, position, lengthWithoutNullTerm) :

System.IO.MemoryMappedFiles (2)

System\IO\MemoryMappedFiles\MemoryMappedFile.Unix.cs (2)

211Debug.Fail($"shm_open failed with ENAMETOOLONG for {Encoding.UTF8.GetByteCount(mapName)} byte long name."); 269Debug.Assert(Encoding.UTF8.GetByteCount(span) <= MaxNameLength); // the standard uses Utf8

System.IO.Packaging (3)

System\IO\Packaging\InternalRelationshipCollection.cs (1)

461using (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.Memory.Data (2)

System\BinaryData.cs (2)

144_bytes = Encoding.UTF8.GetBytes(data); 430return Encoding.UTF8.GetString(ptr, span.Length);

System.Net.Http (10)

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

439byte[] buffer = Encoding.UTF8.GetBytes(input);

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

71byte[] utf8bytes = ArrayPool<byte>.Shared.Rent(Encoding.UTF8.GetMaxByteCount(input.Length)); 72int utf8length = Encoding.UTF8.GetBytes(input, 0, input.Length, utf8bytes, 0);

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

26internal static readonly Encoding DefaultStringEncoding = Encoding.UTF8; 42AssertEncodingConstants(Encoding.UTF8, UTF8CodePage, UTF8Preamble); 730encoding = Encoding.UTF8;

System\Net\Http\SocketsHttpHandler\AuthenticationHelper.cs (1)

182string base64AuthString = Convert.ToBase64String(Encoding.UTF8.GetBytes(authString));

System\Net\Http\SocketsHttpHandler\AuthenticationHelper.Digest.cs (1)

216byte[] dataBytes = Encoding.UTF8.GetBytes(data);

System\Net\Http\SocketsHttpHandler\SocksHelper.cs (2)

324return checked((byte)Encoding.UTF8.GetBytes(chars, buffer)); 328Debug.Assert(Encoding.UTF8.GetByteCount(chars) > 255);

System.Net.Http.Json (5)

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

136return JsonHelpers.GetEncoding(content) is Encoding sourceEncoding && sourceEncoding != Encoding.UTF8

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

20return Encoding.CreateTranscodingStream(contentStream, innerStreamEncoding: sourceEncoding, outerStreamEncoding: Encoding.UTF8);

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

117return targetEncoding != null && targetEncoding != Encoding.UTF8 126Stream transcodingStream = Encoding.CreateTranscodingStream(targetStream, targetEncoding, Encoding.UTF8, leaveOpen: true);

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

16if (JsonHelpers.GetEncoding(this) is Encoding targetEncoding && targetEncoding != Encoding.UTF8)

System.Net.HttpListener (4)

src\libraries\Common\src\System\Net\WebSockets\WebSocketValidate.cs (2)

85Encoding.UTF8.GetMaxByteCount(statusDescription.Length) > MaxControlFramePayloadLength && 86Encoding.UTF8.GetByteCount(statusDescription) > MaxControlFramePayloadLength)

System\Net\Managed\HttpListenerContext.Managed.cs (1)

69string authString = Encoding.UTF8.GetString(Convert.FromBase64String(headerValue));

System\Net\WebSockets\HttpWebSocket.cs (1)

22byte[] toHash = Encoding.UTF8.GetBytes(acceptString);

System.Net.Mail (6)

System\Net\BufferBuilder.cs (2)

77int byteCount = Encoding.UTF8.GetByteCount(value, offset, count); 79Encoding.UTF8.GetBytes(value, offset, count, _buffer, _offset);

System\Net\Mail\SmtpLoginAuthenticationModule.cs (2)

39return new Authorization(Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(userName)), false); 45return new Authorization(Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(cachedCredential.Password)), true);

System\Net\Mail\SmtpReplyReaderFactory.cs (1)

302builder.Append(Encoding.UTF8.GetString(_byteBuffer, start, actual));

System\Net\Mime\MimeBasePart.cs (1)

23encoding == Encoding.Unicode || encoding == Encoding.UTF8 || encoding == Encoding.UTF32 || encoding == Encoding.BigEndianUnicode;

System.Net.Ping (2)

src\libraries\Common\src\System\Text\ValueUtf8Converter.cs (2)

26int maxSize = checked(Encoding.UTF8.GetMaxByteCount(value.Length) + 1); 35int byteCount = Encoding.UTF8.GetBytes(value, _bytes);

System.Net.Primitives (2)

src\libraries\Common\src\System\Net\NetworkInformation\InterfaceInfoPal.Unix.cs (2)

39bufferSize = Encoding.UTF8.GetByteCount(castInterfaceName) + 1; 60Encoding.UTF8.GetBytes(castInterfaceName, buffer);

System.Net.Quic (3)

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

System\Net\CommandStream.cs (1)

469private Encoding _encoding = Encoding.UTF8;

System\Net\FtpControlStream.cs (1)

287Encoding = Encoding.UTF8;

System.Net.Security (8)

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\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.OpenSsl.cs (1)

623index += Encoding.UTF8.GetBytes(alg, buffer.AsSpan(index));

src\libraries\Common\src\Microsoft\Win32\SafeHandles\GssSafeHandles.cs (3)

22out minorStatus, name, Encoding.UTF8.GetByteCount(name), out retHandle); 39out minorStatus, name, Encoding.UTF8.GetByteCount(name), out retHandle); 120status = Interop.NetSecurityNative.InitiateCredWithPassword(out minorStatus, packageType, userHandle, password, Encoding.UTF8.GetByteCount(password), out retHandle);

System\Net\NegotiateAuthenticationPal.Unix.cs (1)

540return Encoding.UTF8.GetString(tokenBytes);

System\Net\Security\SslApplicationProtocol.cs (1)

12private static readonly Encoding s_utf8 = Encoding.GetEncoding(Encoding.UTF8.CodePage, EncoderFallback.ExceptionFallback, DecoderFallback.ExceptionFallback);

System.Net.ServerSentEvents (4)

System\Net\ServerSentEvents\Helpers.cs (2)

48int maxByteCount = Encoding.UTF8.GetMaxByteCount(value.Length); 53bytesWritten = Encoding.UTF8.GetBytes(value, buffer);

System\Net\ServerSentEvents\SseParser.cs (2)

26/// that decodes the data of each event using <see cref="Encoding.UTF8"/>'s GetString method. 56return Encoding.UTF8.GetString(bytes);

System.Net.Sockets (3)

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

System\Net\WebClient.cs (2)

510formHeaderBytes = Encoding.UTF8.GetBytes(formHeader); 1086private static readonly Encoding[] s_knownEncodings = { Encoding.UTF8, Encoding.UTF32, Encoding.Unicode, Encoding.BigEndianUnicode };

System.Net.WebSockets (2)

src\libraries\Common\src\System\Net\WebSockets\WebSocketValidate.cs (2)

85Encoding.UTF8.GetMaxByteCount(statusDescription.Length) > MaxControlFramePayloadLength && 86Encoding.UTF8.GetByteCount(statusDescription) > MaxControlFramePayloadLength)

System.Net.WebSockets.Client (2)

src\libraries\Common\src\System\Net\WebSockets\WebSocketValidate.cs (2)

85Encoding.UTF8.GetMaxByteCount(statusDescription.Length) > MaxControlFramePayloadLength && 86Encoding.UTF8.GetByteCount(statusDescription) > MaxControlFramePayloadLength)

System.Private.CoreLib (119)

src\libraries\Common\src\Internal\VersionResilientHashCode.cs (1)

31byte[] src = Encoding.UTF8.GetBytes(name);

src\libraries\Common\src\Interop\Linux\procfs\Interop.ProcFsStat.TryReadStatusFile.cs (1)

155contents = Encoding.UTF8.GetString(bytes, 0, count);

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\libraries\Common\src\Interop\Unix\System.Native\Interop.ReadLink.cs (1)

57return Encoding.UTF8.GetString(spanBuffer.Slice(0, resultLength));

src\libraries\Common\src\System\Text\ValueUtf8Converter.cs (2)

26int maxSize = checked(Encoding.UTF8.GetMaxByteCount(value.Length) + 1); 35int byteCount = Encoding.UTF8.GetBytes(value, _bytes);

src\libraries\System.Private.CoreLib\src\Internal\Console.Unix.cs (2)

15byte[] bytes = Encoding.UTF8.GetBytes(s); 27byte[] bytes = Encoding.UTF8.GetBytes(s);

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventProvider.cs (2)

1336string key = Text.Encoding.UTF8.GetString(data, dataStart, keyEnd - dataStart); 1337string value = Text.Encoding.UTF8.GetString(data, valueIdx, valueEnd - valueIdx);

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventSource.cs (2)

457return (manifestBytes == null) ? null : Encoding.UTF8.GetString(manifestBytes, 0, manifestBytes.Length); 5617return (str != "") ? Encoding.UTF8.GetBytes(str) : Array.Empty<byte>();

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\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\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\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\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\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\libraries\System.Private.CoreLib\src\System\Globalization\NumberFormatInfo.cs (15)

src\libraries\System.Private.CoreLib\src\System\IO\BinaryReader.cs (1)

31public BinaryReader(Stream input) : this(input, Encoding.UTF8, false)

src\libraries\System.Private.CoreLib\src\System\IO\BinaryWriter.cs (2)

32_encoding = Encoding.UTF8; 37public BinaryWriter(Stream output) : this(output, Encoding.UTF8, false)

src\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\libraries\System.Private.CoreLib\src\System\IO\File.cs (6)

624=> ReadAllText(path, Encoding.UTF8); 864=> ReadAllLines(path, Encoding.UTF8); 883=> ReadLines(path, Encoding.UTF8); 899=> ReadLinesAsync(path, Encoding.UTF8, cancellationToken); 1084=> ReadAllTextAsync(path, Encoding.UTF8, cancellationToken); 1292=> ReadAllLinesAsync(path, Encoding.UTF8, cancellationToken);

src\libraries\System.Private.CoreLib\src\System\IO\FileInfo.cs (1)

81=> new StreamReader(NormalizedPath, Encoding.UTF8, detectEncodingFromByteOrderMarks: true);

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\libraries\System.Private.CoreLib\src\System\IO\StreamReader.cs (5)

110: this(stream, Encoding.UTF8, detectEncodingFromByteOrderMarks, DefaultBufferSize, false) 158_encoding = encoding ??= Encoding.UTF8; 186: this(path, Encoding.UTF8, detectEncodingFromByteOrderMarks, DefaultBufferSize) 206: this(path, Encoding.UTF8, true, options) 503_encoding = Encoding.UTF8;

src\libraries\System.Private.CoreLib\src\System\Net\WebUtility.cs (3)

345int byteCount = Encoding.UTF8.GetByteCount(value); 351Encoding.UTF8.GetBytes(state.value, utf8Bytes); 560return UrlDecodeInternal(encodedValue, Encoding.UTF8);

src\libraries\System.Private.CoreLib\src\System\Number.Formatting.cs (1)

663return Encoding.UTF8.TryGetBytes(source, Unsafe.BitCast<Span<TChar>, Span<byte>>(destination), out charsWritten);

src\libraries\System.Private.CoreLib\src\System\Number.Parsing.cs (1)

1058SR.Format(SR.Format_InvalidStringWithValue, Encoding.UTF8.GetString(bytes)) :

src\libraries\System.Private.CoreLib\src\System\Numerics\INumberBase.cs (5)

310int textMaxCharCount = Encoding.UTF8.GetMaxCharCount(utf8Text.Length); 444int textMaxCharCount = Encoding.UTF8.GetMaxCharCount(utf8Text.Length); 490int destinationMaxCharCount = Encoding.UTF8.GetMaxCharCount(utf8Destination.Length); 546int textMaxCharCount = Encoding.UTF8.GetMaxCharCount(utf8Text.Length); 593int textMaxCharCount = Encoding.UTF8.GetMaxCharCount(utf8Text.Length);

src\libraries\System.Private.CoreLib\src\System\Resources\ResourceReader.Core.cs (1)

34_store = new BinaryReader(stream, Encoding.UTF8);

src\libraries\System.Private.CoreLib\src\System\Resources\ResourceReader.cs (2)

101_store = new BinaryReader(new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read, DefaultFileStreamBufferSize, FileOptions.RandomAccess), Encoding.UTF8); 133_store = new BinaryReader(stream, Encoding.UTF8);

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); 1031int nb = Encoding.UTF8.GetMaxByteCount(s.Length); 1036int nbWritten = Encoding.UTF8.GetBytes(s, new Span<byte>(pbMem, nb)); 1072int nb = Encoding.UTF8.GetMaxByteCount(s.Length); 1077int nbWritten = Encoding.UTF8.GetBytes(s, new Span<byte>(pbMem, nb));

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshal.Unix.cs (3)

39int convertedBytes = Encoding.UTF8.GetBytes(s, new Span<byte>(buffer, bufferLength)); 48int byteLength = Encoding.UTF8.GetByteCount(chars); 55int actualByteLength = Encoding.UTF8.GetBytes(chars, bytes);

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshalling\Utf8StringMarshaller.cs (4)

27int exactByteCount = checked(Encoding.UTF8.GetByteCount(managed) + 1); // + 1 for null terminator 31int byteCount = Encoding.UTF8.GetBytes(managed, buffer); 86int exactByteCount = checked(Encoding.UTF8.GetByteCount(managed) + 1); // + 1 for null terminator 97int byteCount = Encoding.UTF8.GetBytes(managed, buffer);

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\TypeMapLazyDictionary.cs (4)

113? Encoding.UTF8.GetMaxCharCount(utf8TypeName.Length) 114: Encoding.UTF8.GetCharCount(utf8TypeName); 117int converted = Encoding.UTF8.GetChars(utf8TypeName, buffer); 131string externalTypeName = new((sbyte*)arg->Utf8String1, 0, arg->StringLen1, Encoding.UTF8);

src\libraries\System.Private.CoreLib\src\System\String.cs (1)

247return CreateStringFromEncoding(pb, numBytes, Encoding.UTF8);

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

213case CodePageUTF8: return UTF8; // 65001

src\libraries\System.Private.CoreLib\src\System\Text\Unicode\Utf8.cs (1)

574if (Encoding.UTF8.TryGetBytes(value, _destination.Slice(_pos), out int bytesWritten))

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\libraries\System.Private.CoreLib\src\System\TimeZoneInfo.Unix.cs (1)

1203Encoding enc = Encoding.UTF8;

src\libraries\System.Private.CoreLib\src\System\TimeZoneInfo.Unix.NonAndroid.cs (1)

174using var reader = new StreamReader(fileName, Encoding.UTF8);

src\System\Reflection\Emit\CustomAttributeBuilder.cs (1)

354byte[] utf8Str = Encoding.UTF8.GetBytes(str);

src\System\Reflection\MdImport.cs (5)

264: Text.Encoding.UTF8.GetString(MemoryMarshal.CreateReadOnlySpanFromNullTerminated(safeArrayUserDefinedSubTypeRaw)); 267: Text.Encoding.UTF8.GetString(MemoryMarshal.CreateReadOnlySpanFromNullTerminated(marshalTypeRaw)); 270: Text.Encoding.UTF8.GetString(MemoryMarshal.CreateReadOnlySpanFromNullTerminated(marshalCookieRaw)); 601importName = Text.Encoding.UTF8.GetString(MemoryMarshal.CreateReadOnlySpanFromNullTerminated(importNameRaw)); 602importDll = Text.Encoding.UTF8.GetString(MemoryMarshal.CreateReadOnlySpanFromNullTerminated(importDllRaw));

src\System\Reflection\RuntimeCustomAttributeData.cs (1)

1013return Encoding.UTF8.GetString(utf8ByteSpan);

src\System\RuntimeType.CoreCLR.cs (3)

335int cUtf8Name = Encoding.UTF8.GetByteCount(name); 351Encoding.UTF8.GetBytes(name, utf8Name); 4331=> Encoding.UTF8.GetString(new ReadOnlySpan<byte>(m_pStringHeap, m_StringHeapByteLength));

src\System\StubHelpers.cs (3)

167cbWritten = Encoding.UTF8.GetBytes(pwzChar, numChars, buffer, length); 209int nb = Encoding.UTF8.GetByteCount(strManaged); 213nb = strManaged.GetBytesFromEncoding(pbNativeBuffer, nb, Encoding.UTF8);

src\System\Text\StringBuilder.CoreCLR.cs (3)

46int numChars = Encoding.UTF8.GetCharCount(source); 52m_ChunkLength = Encoding.UTF8.GetChars(source, m_ChunkChars); 92convertedChars = Encoding.UTF8.GetChars((byte*)newBuffer, newLength, pChunkChars, newLength);

src\System\Threading\Mutex.CoreCLR.Unix.cs (1)

164SR.Format(SR.Unix_SystemCallErrors, Encoding.UTF8.GetString(systemCallErrors, systemCallErrorsLength));

System.Private.CoreLib.Generators (4)

EventSourceGenerator.Emitter.cs (3)

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

NativeRuntimeEventSourceGenerator.cs (1)

56spc.AddSource($"{className}.g.cs", SourceText.From(source, System.Text.Encoding.UTF8));

System.Private.DataContractSerialization (37)

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

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

System\Runtime\Serialization\Json\DataContractJsonSerializer.cs (1)

303XmlDictionaryWriter jsonWriter = JsonReaderWriterFactory.CreateJsonWriter(stream, Encoding.UTF8, false); // ownsStream

System\Runtime\Serialization\Json\JsonEncodingStreamWrapper.cs (1)

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

System\Runtime\Serialization\Json\JsonReaderWriterFactory.cs (1)

50return CreateJsonWriter(stream, Encoding.UTF8, true);

System\Runtime\Serialization\Json\JsonXmlDataContract.cs (1)

33MemoryStream memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(xmlContent));

System\Runtime\Serialization\Json\XmlJsonReader.cs (8)

603XmlExceptionHelper.ThrowTokenExpected(this, "false", Encoding.UTF8.GetString(buffer, offset, 5)); 611XmlExceptionHelper.ThrowTokenExpected(this, "false", Encoding.UTF8.GetString(buffer, offset, 4) + (char)ch); 624XmlExceptionHelper.ThrowTokenExpected(this, "true", Encoding.UTF8.GetString(buffer, offset, 4)); 632XmlExceptionHelper.ThrowTokenExpected(this, "true", Encoding.UTF8.GetString(buffer, offset, 4) + (char)ch); 645XmlExceptionHelper.ThrowTokenExpected(this, "null", Encoding.UTF8.GetString(buffer, offset, 4)); 658XmlExceptionHelper.ThrowTokenExpected(this, "null", Encoding.UTF8.GetString(buffer, offset, 4) + (char)ch); 1196string bufferAsString = Encoding.UTF8.GetString(buffer, offset, 4); 1207bufferAsString = Encoding.UTF8.GetString(buffer, offset, 4);

System\Runtime\Serialization\Json\XmlJsonWriter.cs (1)

241if (encoding.WebName != Encoding.UTF8.WebName)

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

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

System\Xml\EncodingStreamWrapper.cs (1)

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

System\Xml\XmlBaseWriter.cs (1)

1644_textFragmentWriter.SetOutput(stream, false, Encoding.UTF8);

System\Xml\XmlCanonicalWriter.cs (7)

184_element.prefixLength = Encoding.UTF8.GetByteCount(prefix); 186_element.localNameLength = Encoding.UTF8.GetByteCount(localName); 254if (string.Equals(Encoding.UTF8.GetString(_xmlnsBuffer!, xmlnsAttribute.prefixOffset, xmlnsAttribute.prefixLength), _inclusivePrefixes[i], StringComparison.Ordinal)) 371xmlnsAttribute.prefixLength = Encoding.UTF8.GetBytes(prefix, 0, prefix.Length, _xmlnsBuffer, _xmlnsOffset); 374xmlnsAttribute.nsLength = Encoding.UTF8.GetBytes(ns, 0, ns.Length, _xmlnsBuffer, _xmlnsOffset); 424_attribute.prefixLength = Encoding.UTF8.GetByteCount(prefix); 426_attribute.localNameLength = Encoding.UTF8.GetByteCount(localName);

System\Xml\XmlDictionaryString.cs (1)

78return _buffer ??= System.Text.Encoding.UTF8.GetBytes(_value);

System\Xml\XmlNodeWriter.cs (8)

System\Xml\XmlUTF8TextReader.cs (2)

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

System\Xml\XmlUTF8TextWriter.cs (2)

25if (encoding.WebName != Encoding.UTF8.WebName) 93if (encoding != null && encoding.CodePage == Encoding.UTF8.CodePage)

System.Private.Windows.Core (4)

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

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

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

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

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

193return Encoding.UTF8.GetString((byte*)buffer, size - 1);

System.Private.Xml (6)

System\Xml\Core\XmlTextReaderImpl.cs (1)

3177_ps.encoding = Encoding.UTF8;

System\Xml\Core\XmlWriterSettings.cs (2)

367Debug.Assert(Encoding.UTF8.WebName == "utf-8"); 503_encoding = Encoding.UTF8;

System\Xml\Serialization\Compiler.cs (1)

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

System\Xml\Xsl\XsltOld\SequentialOutput.cs (1)

609_utf8Encoding = Encoding.UTF8;

System\Xml\Xsl\XsltOld\XsltOutput.cs (1)

26private Encoding _encoding = System.Text.Encoding.UTF8;

System.Reflection.Emit (1)

System\Reflection\Emit\CustomAttributeWrapper.cs (1)

97return Text.Encoding.UTF8.GetString(data.Slice(pos, len));

System.Reflection.Metadata (5)

System\Reflection\Internal\Utilities\MemoryBlock.cs (1)

282return Encoding.UTF8.GetString(Pointer + offset, byteCount);

System\Reflection\Metadata\Internal\StringHeap.cs (1)

215StringKind.Virtual => Encoding.UTF8.GetBytes(GetVirtualString(handle.GetVirtualIndex())),

System\Reflection\Metadata\MetadataStringDecoder.cs (1)

35public static MetadataStringDecoder DefaultUTF8 { get; } = new MetadataStringDecoder(Encoding.UTF8);

System\Reflection\PortableExecutable\PEBinaryReader.cs (2)

32_reader = new BinaryReader(stream, Encoding.UTF8, leaveOpen: true); 107return Encoding.UTF8.GetString(bytes, 0, nonPaddedLength);

System.Reflection.MetadataLoadContext (2)

System\Reflection\TypeLoading\General\Helpers.cs (2)

367public static byte[] ToUtf8(this string s) => Encoding.UTF8.GetBytes(s); 370public static string ToUtf16(this ReadOnlySpan<byte> utf8) => Encoding.UTF8.GetString(utf8);

System.Resources.Extensions (4)

src\libraries\Common\src\System\Resources\ResourceWriter.cs (2)

248BinaryWriter bw = new BinaryWriter(_output, Encoding.UTF8); 303BinaryWriter data = new BinaryWriter(dataSection, Encoding.UTF8);

src\libraries\System.Private.CoreLib\src\System\Resources\ResourceReader.cs (2)

System.Resources.Writer (2)

src\libraries\Common\src\System\Resources\ResourceWriter.cs (2)

248BinaryWriter bw = new BinaryWriter(_output, Encoding.UTF8); 303BinaryWriter data = new BinaryWriter(dataSection, Encoding.UTF8);

System.Security.Cryptography (12)

src\libraries\Common\src\Interop\Unix\System.Native\Interop.ReadLink.cs (1)

57return Encoding.UTF8.GetString(spanBuffer.Slice(0, resultLength));

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\libraries\Common\src\System\Security\Cryptography\PasswordBasedEncryption.cs (3)

182encoding = System.Text.Encoding.UTF8; 329System.Text.Encoding encoding = System.Text.Encoding.UTF8; 467encoding = System.Text.Encoding.UTF8;

src\libraries\Common\src\System\Text\ValueUtf8Converter.cs (2)

26int maxSize = checked(Encoding.UTF8.GetMaxByteCount(value.Length) + 1); 35int byteCount = Encoding.UTF8.GetBytes(value, _bytes);

System\Security\Cryptography\OpenSslAsnFormatter.cs (1)

81return Encoding.UTF8.GetString(buffer.Slice(0, total));

System\Security\Cryptography\Rfc2898DeriveBytes.cs (2)

59Encoding.UTF8.GetBytes(password ?? throw new ArgumentNullException(nameof(password))), 89byte[] passwordBytes = Encoding.UTF8.GetBytes(password);

System\Security\Cryptography\X509Certificates\OpenSslX509CertificateReader.cs (1)

815return Encoding.UTF8.GetString(buffer.Slice(0, total));

System.Security.Cryptography.Pkcs (3)

src\libraries\Common\src\System\Security\Cryptography\PasswordBasedEncryption.cs (3)

182encoding = System.Text.Encoding.UTF8; 329System.Text.Encoding encoding = System.Text.Encoding.UTF8; 467encoding = System.Text.Encoding.UTF8;

System.Security.Cryptography.Xml (16)

System\Security\Cryptography\Xml\CanonicalXml.cs (1)

102return Encoding.UTF8.GetBytes(sb.ToString());

System\Security\Cryptography\Xml\CanonicalXmlAttribute.cs (2)

35byte[] rgbData = Encoding.UTF8.GetBytes(" " + Name + "=\""); 37rgbData = Encoding.UTF8.GetBytes(Utils.EscapeAttributeValue(Value));

System\Security\Cryptography\Xml\CanonicalXmlCDataSection.cs (1)

34byte[] rgbData = Encoding.UTF8.GetBytes(Utils.EscapeCData(Data));

System\Security\Cryptography\Xml\CanonicalXmlComment.cs (1)

61rgbData = Encoding.UTF8.GetBytes(Value!);

System\Security\Cryptography\Xml\CanonicalXmlElement.cs (2)

139rgbData = Encoding.UTF8.GetBytes("<" + Name); 167rgbData = Encoding.UTF8.GetBytes("</" + Name + ">");

System\Security\Cryptography\Xml\CanonicalXmlProcessingInstruction.cs (2)

57rgbData = Encoding.UTF8.GetBytes(Name); 62rgbData = Encoding.UTF8.GetBytes(" " + Value);

System\Security\Cryptography\Xml\CanonicalXmlSignificantWhitespace.cs (1)

36byte[] rgbData = Encoding.UTF8.GetBytes(Utils.EscapeWhitespaceData(Value));

System\Security\Cryptography\Xml\CanonicalXmlText.cs (1)

36byte[] rgbData = Encoding.UTF8.GetBytes(Utils.EscapeTextData(Value));

System\Security\Cryptography\Xml\CanonicalXmlWhitespace.cs (1)

36byte[] rgbData = Encoding.UTF8.GetBytes(Utils.EscapeWhitespaceData(Value));

System\Security\Cryptography\Xml\EncryptedXml.cs (1)

98_encoding = Encoding.UTF8;

System\Security\Cryptography\Xml\ExcCanonicalXml.cs (1)

55return Encoding.UTF8.GetBytes(sb.ToString());

System\Security\Cryptography\Xml\SignedXmlDebugLog.cs (1)

605Encoding.UTF8.GetString(ms.ToArray()));

System\Security\Cryptography\Xml\XmlDsigBase64Transform.cs (1)

101byte[] buffer = Encoding.UTF8.GetBytes(sb.ToString());

System.ServiceModel.Federation (2)

System\ServiceModel\Federation\WSTrustChannelSecurityTokenProvider.cs (2)

237var writer = XmlDictionaryWriter.CreateTextWriter(memeoryStream, Encoding.UTF8); 276var writer = XmlDictionaryWriter.CreateTextWriter(memeoryStream, Encoding.UTF8);

System.ServiceModel.Http (1)

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

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

System.ServiceModel.NetFramingBase (3)

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.NetNamedPipe (1)

System\ServiceModel\Channels\PipeConnectionInitiator.cs (1)

357byte[] canonicalBytes = Encoding.UTF8.GetBytes(canonicalName);

System.ServiceModel.Primitives (16)

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

32return ParseQueryString(query, Encoding.UTF8); 61return UrlEncode(str, Encoding.UTF8); 80return UrlEncodeSpaces(UrlEncodeNonAscii(str, Encoding.UTF8)); 152e = Encoding.UTF8;

Internals\System\Xml\XmlMtomWriter.cs (1)

194if (string.Compare(name, Encoding.UTF8.WebName, StringComparison.OrdinalIgnoreCase) == 0)

System\IdentityModel\CanonicalFormWriter.cs (1)

14internal static readonly Encoding Utf8WithoutPreamble = Encoding.UTF8;

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

381int utf8ValueSize = Encoding.UTF8.GetByteCount(newStrings[i].Value); 412int utf8ValueSize = Encoding.UTF8.GetByteCount(newString); 414offset += Encoding.UTF8.GetBytes(newString, 0, newString.Length, buffer, offset); 486string value = Encoding.UTF8.GetString(buffer, offset, utf8ValueSize); 903int bytesRequired = Encoding.UTF8.GetByteCount(s.Value);

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

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

System\ServiceModel\Security\Tokens\DerivedKeySecurityToken.cs (1)

201(_label != null ? Encoding.UTF8.GetBytes(_label) : s_DefaultLabel), _nonce, Length * 8,

System\ServiceModel\Security\WSSecurityOneDotZeroSendSecurityHeader.cs (2)

520using (var xmlWriter = XmlDictionaryWriter.CreateTextWriter(stream, Encoding.UTF8, false)) 626using (var xmlWriter = XmlDictionaryWriter.CreateTextWriter(stream, Encoding.UTF8, false))

System.ServiceModel.Primitives.Tests (2)

Channels\TextMessageEncodingBindingElementTest.cs (1)

20Assert.Equal<Encoding>(Encoding.UTF8, element.WriteEncoding);

ServiceModel\ChannelFactoryTest.cs (1)

28new TextMessageEncodingBindingElement(MessageVersion.Default, Encoding.UTF8),

System.Text.Json (4)

System\Text\Json\JsonHelpers.cs (2)

201return Encoding.UTF8.GetString(bytes); 235int charsWritten = Encoding.UTF8.GetChars(utf8Key, charBuffer);

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

490NameAsUtf8Bytes = Encoding.UTF8.GetBytes(Name);

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

83byte[] utf8EncodedName = Encoding.UTF8.GetBytes(propertyName);

System.Text.Json.SourceGeneration (2)

JsonSourceGenerator.Parser.cs (1)

1648byte[] utf8Json = Encoding.UTF8.GetBytes(effectiveJsonPropertyName);

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

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

System.Text.RegularExpressions.Generator (1)

RegexGenerator.Emitter.cs (1)

5560return $"{prefix}{ToHexStringNoDashes(sha.ComputeHash(Encoding.UTF8.GetBytes(toEncode)))}";

System.Web.HttpUtility (7)

System\Web\HttpUtility.cs (5)

81public static NameValueCollection ParseQueryString(string query) => ParseQueryString(query, Encoding.UTF8); 161public static string? UrlEncode(string? str) => UrlEncode(str, Encoding.UTF8); 177public static byte[]? UrlEncodeToBytes(string? str) => UrlEncodeToBytes(str, Encoding.UTF8); 187public static string? UrlDecode(string? str) => UrlDecode(str, Encoding.UTF8); 193public static byte[]? UrlDecodeToBytes(string? str) => UrlDecodeToBytes(str, Encoding.UTF8);

System\Web\Util\HttpEncoder.cs (2)

569byte[] bytes = ArrayPool<byte>.Shared.Rent(Encoding.UTF8.GetMaxByteCount(toEncode.Length)); 570int utf8Length = Encoding.UTF8.GetBytes(toEncode, bytes);

System.Windows.Forms (8)

System\Resources\ResXResourceWriter.cs (2)

161_xmlTextWriter = new XmlTextWriter(_stream, Encoding.UTF8); 166_xmlTextWriter = new XmlTextWriter(_fileName, Encoding.UTF8);

System\Windows\Forms\Controls\DataGridView\DataGridView.Methods.cs (2)

8153byte[] destinationBytes = Encoding.Convert(Encoding.Unicode, Encoding.UTF8, sourceBytes); 8177destinationBytes = Encoding.Convert(Encoding.Unicode, Encoding.UTF8, sourceBytes);

System\Windows\Forms\Controls\RichTextBox\RichTextBox.cs (3)

2817encodedBytes = (CodePagesEncodingProvider.Instance.GetEncoding(0) ?? Encoding.UTF8).GetBytes(str); 2861string str = (CodePagesEncodingProvider.Instance.GetEncoding(0) ?? Encoding.UTF8).GetString(bytes); 2949result = (CodePagesEncodingProvider.Instance.GetEncoding(0) ?? Encoding.UTF8).GetString(bytes, 0, bytes.Length);

System\Windows\Forms\Controls\WebBrowser\WebBrowser.cs (1)

325StreamWriter sw = new(ms, Encoding.UTF8);

System.Windows.Forms.Analyzers.CSharp.Tests (1)

Generators\ApplicationConfigurationGenerator\ApplicationConfigurationGeneratorTests.cs (1)

224return SourceText.From(input, Encoding.UTF8);

System.Windows.Forms.Analyzers.Tests (1)

TestFileLoader.cs (1)

47using var reader = new StreamReader(testFilePath, Encoding.UTF8);

System.Windows.Forms.Design.Tests (1)

System\Resources\Tools\StronglyTypedResourceBuilderTests.cs (1)

707Assert.Equal("HELLO", Encoding.UTF8.GetString(contents));

System.Windows.Forms.Tests (10)

SerializableTypesTests.cs (2)

29byte[] bytes = Encoding.UTF8.GetBytes(payload); 67Assert.Equal(payload, Encoding.UTF8.GetString(buffer));

System\Resources\ResXResourceReaderTests.cs (1)

77byte[] resxBytes = Encoding.UTF8.GetBytes(ResxHelper.CreateResx());

System\Windows\Forms\HtmlDocumentTests.cs (1)

2388byte[] data = Encoding.UTF8.GetBytes(html);

System\Windows\Forms\HtmlElementTests.cs (1)

3334byte[] data = Encoding.UTF8.GetBytes(html);

System\Windows\Forms\HtmlWindowTests.cs (1)

108byte[] data = Encoding.UTF8.GetBytes(html);

System\Windows\Forms\RichTextBoxTests.cs (1)

9758int currentCodePage = (CodePagesEncodingProvider.Instance.GetEncoding(0) ?? Encoding.UTF8).CodePage;

System\Windows\Forms\WebBrowserTests.cs (3)

539Assert.Equal(Html, Encoding.UTF8.GetString(documentStream.ToArray())); 579using MemoryStream value = new(Encoding.UTF8.GetBytes(Html)); 4651byte[] data = Encoding.UTF8.GetBytes(html);

Templates.Tests (1)

ByteOrderMarkTest.cs (1)

93var expectedBytes = Encoding.UTF8.GetPreamble();

Test.Utilities (8)

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

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

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

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

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

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

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

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

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

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

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

TestContentPackage (2)

CustomIntSerializer.cs (2)

19var bytes = Encoding.UTF8.GetBytes(customFormat); 26var text = Encoding.UTF8.GetString(bytes);

Text.Analyzers (8)

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

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

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

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

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

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

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

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

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

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

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

UnitTests.Common (1)

TestData.cs (1)

50{ Encoding.UTF8 },

vbc (2)

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

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

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

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

VBCSCompiler (2)

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

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

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

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

WebSocketSample (2)

Program.cs (2)

37var bytes = Encoding.UTF8.GetBytes(line); 59Console.WriteLine(Encoding.UTF8.GetString(buffer, 0, result.Count));