Encoding

18 types derived from Encoding

dotnet-svcutil-lib (3)

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

213internal class Ucs4Encoding : Encoding

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

14internal class Base64Encoding : Encoding

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

11internal class BinHexEncoding : Encoding

Roslyn.VisualStudio.Next.UnitTests (1)

Remote\SnapshotSerializationTests.cs (1)

746private sealed class NotSerializableEncoding : Encoding

System.Console (1)

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

24internal sealed class ConsoleEncoding : Encoding

System.Formats.Asn1 (2)

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

77internal abstract class SpanBasedEncoding : Encoding 418internal sealed class T61Encoding : Encoding

System.Private.CoreLib (7)

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

22public partial class ASCIIEncoding : Encoding

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

15internal partial class Latin1Encoding : Encoding

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

6internal partial class Latin1Encoding : Encoding

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

19public class UnicodeEncoding : Encoding

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

22public sealed class UTF32Encoding : Encoding

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

14public class UTF7Encoding : Encoding

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

33public partial class UTF8Encoding : Encoding

System.Private.DataContractSerialization (2)

System\Text\Base64Encoding.cs (1)

12internal sealed class Base64Encoding : Encoding

System\Text\BinHexEncoding.cs (1)

9internal sealed class BinHexEncoding : Encoding

System.Private.Xml (1)

System\Xml\XmlEncoding.cs (1)

212internal class Ucs4Encoding : Encoding

System.Text.Encoding.CodePages (1)

System\Text\EncodingNLS.cs (1)

24internal abstract class EncodingNLS : Encoding

6093 references to Encoding

AnalyzerRunner (2)

DiagnosticAnalyzerRunner.cs (2)

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

aspire (1)

Program.cs (1)

160System.Console.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 (2)

Utils\CliTestHelper.cs (2)

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

ConsumerConfigurationTests.cs (1)

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

KafkaContainerFixture.cs (1)

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

ProducerConfigurationTests.cs (1)

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

Aspire.Dashboard (8)

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

192var jsonData = Encoding.UTF8.GetBytes(jsonString); 257var 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 (10)

Pages\TraceDetailsTests.cs (5)

75var traceId = Convert.ToHexString(Encoding.UTF8.GetBytes("1")); 130var traceId = Convert.ToHexString(Encoding.UTF8.GetBytes("1")); 146traceId = Convert.ToHexString(Encoding.UTF8.GetBytes("2")); 212var traceId = Convert.ToHexString(Encoding.UTF8.GetBytes("1")); 269var traceId = Convert.ToHexString(Encoding.UTF8.GetBytes("1"));

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

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

Aspire.Dashboard.Tests (16)

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

Aspire.Hosting (10)

Dashboard\ResourceServiceOptions.cs (1)

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

Dcp\DcpHost.cs (2)

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

Dcp\DcpKubernetesClient.cs (1)

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

DistributedApplicationBuilder.cs (2)

215var appHostNameShaBytes = SHA256.HashData(Encoding.UTF8.GetBytes(appHostName)); 220var 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)

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

Provisioning\Provisioners\BicepProvisioner.cs (1)

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

Aspire.Hosting.Azure.Tests (2)

AzureEventHubsExtensionsTests.cs (2)

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

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)

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

Aspire.Hosting.RabbitMQ.Tests (4)

RabbitMQFunctionalTests.cs (4)

85var body = Encoding.UTF8.GetBytes(message); 90Assert.Equal(message, Encoding.UTF8.GetString(result!.Body.Span)); 148var body = Encoding.UTF8.GetBytes(message); 205Assert.Equal("Hello World!", Encoding.UTF8.GetString(result!.Body.Span));

Aspire.Hosting.Seq.Tests (1)

SeqFunctionalTests.cs (1)

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

Aspire.Hosting.Tests (11)

AspireStoreTests.cs (2)

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

Dcp\DcpExecutorTests.cs (6)

608await pipes.StandardOut.Writer.WriteAsync(Encoding.UTF8.GetBytes("2024-08-19T06:10:33.473275911Z Hello world" + Environment.NewLine)); 619await pipes.StandardErr.Writer.WriteAsync(Encoding.UTF8.GetBytes("2024-08-19T06:10:32.661Z Next" + Environment.NewLine)); 662return new MemoryStream(Encoding.UTF8.GetBytes("2024-08-19T06:10:01.000Z First" + Environment.NewLine)); 664return new MemoryStream(Encoding.UTF8.GetBytes("2024-08-19T06:10:02.000Z Second" + Environment.NewLine)); 666return new MemoryStream(Encoding.UTF8.GetBytes("2024-08-19T06:10:03.000Z Third" + Environment.NewLine)); 668return 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)

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

UserSecretsParameterDefaultTests.cs (1)

65File.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 (8)

Formatters\CustomFormatter.cs (2)

18SupportedEncodings.Add(Encoding.GetEncoding("utf-8")); 34public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding)

Formatters\PlainTextFormatter.cs (2)

15SupportedEncodings.Add(Encoding.GetEncoding("utf-8")); 32public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding)

Formatters\VCardFormatter_V3.cs (2)

20SupportedEncodings.Add(Encoding.UTF8); 29public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding)

Formatters\VCardFormatter_V4.cs (2)

21SupportedEncodings.Add(Encoding.UTF8); 30public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding)

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)

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

BuildBoss (3)

OptProfCheckerUtil.cs (1)

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

SharedUtil.cs (2)

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

BuildValidator (1)

Program.cs (1)

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

CodeGenerator (13)

HttpUtilities\HttpUtilities.cs (1)

310var bytes = Encoding.ASCII.GetBytes(str);

src\Servers\Kestrel\shared\KnownHeaders.cs (4)

472public byte[] Bytes => Encoding.ASCII.GetBytes($"\r\n{Name}: "); 1487case ""{Encoding.ASCII.GetString(value.Field.Value)}"": 1503var groupedHeaders = staticHeaders.GroupBy(h => Encoding.ASCII.GetString(h.HeaderField.Name)).Select(g => 1524var groupedHeaders = staticHeaders.GroupBy(h => Encoding.ASCII.GetString(h.HeaderField.Name)).Select(g =>

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

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

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

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

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

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

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

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

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

src\Compilers\Core\CommandLine\BuildProtocol.cs (4)

136using var reader = new BinaryReader(inStream, Encoding.Unicode, leaveOpen: true); 161using var writer = new BinaryWriter(memoryStream, Encoding.Unicode); 284using (var writer = new BinaryWriter(memoryStream, Encoding.Unicode)) 332using (var reader = new BinaryReader(new MemoryStream(responseBuffer), Encoding.Unicode))

src\Compilers\Core\CommandLine\CompilerServerLogger.cs (1)

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

src\Compilers\Core\CommandLine\ConsoleUtil.cs (2)

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

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

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

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

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

CSharpErrorFactsGenerator (1)

Program.cs (1)

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

CSharpSyntaxGenerator (4)

SourceGenerator.cs (4)

126var sourceText = new StringBuilderText(stringBuilder, encoding: Encoding.UTF8); 174private readonly Encoding? _encoding; 176public StringBuilderText(StringBuilder builder, Encoding? encoding) 182public override Encoding? Encoding => _encoding;

CustomAuthorizationFailureResponse (1)

Authorization\SampleAuthorizationMiddlewareResultHandler.cs (1)

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

dotnet-dev-certs (5)

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

543pemEnvelope = Encoding.ASCII.GetBytes(pem); 559pemEnvelope = Encoding.ASCII.GetBytes(pem); 565bytes = Encoding.ASCII.GetBytes(PemEncoding.Write("CERTIFICATE", certificate.Export(X509ContentType.Cert))); 575bytes = Encoding.ASCII.GetBytes(PemEncoding.Write("CERTIFICATE", certificate.Export(X509ContentType.Cert))); 677bytePayload = Encoding.ASCII.GetBytes(AspNetHttpsOidFriendlyName);

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

CmdCredentialsProvider.cs (1)

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

CodeDomFixup\MethodCreationHelper.cs (6)

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

CodeSerializer.cs (1)

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

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

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

FrameworkFork\Microsoft.CodeDom\Compiler\IndentTextWriter.cs (1)

56public override Encoding Encoding

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

713using (StreamWriter sw = new StreamWriter(temp, Encoding.UTF8)) 3928string[] lines = ReadAllLines(outputFile, Encoding.UTF8, FileShare.ReadWrite); 3952private static string[] ReadAllLines(String file, Encoding encoding, FileShare share) 4180using (StreamWriter sw = new StreamWriter(temp, Encoding.UTF8)) 4241using (StreamWriter sw = new StreamWriter(temp, Encoding.UTF8))

FrameworkFork\Microsoft.Xml\Xml\BinaryXml\XmlBinaryReader.cs (8)

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

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

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

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

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

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

1718internal static Encoding GetEncoding(XmlReader reader)

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

391public Encoding Encoding

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

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

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

36internal Encoding encoding;

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

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

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

50protected Encoding encoding;

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

339public Encoding Encoding

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

441internal Encoding Encoding

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

26void SetInput(byte[] buffer, int offset, int count, Encoding encoding, XmlDictionaryReaderQuotas quotas, OnXmlDictionaryReaderClose onClose); 27void SetInput(Stream stream, Encoding encoding, XmlDictionaryReaderQuotas quotas, OnXmlDictionaryReaderClose onClose); 562public void SetInput(byte[] buffer, int offset, int count, Encoding encoding, XmlDictionaryReaderQuotas quotas, OnXmlDictionaryReaderClose onClose) 580public void SetInput(Stream stream, Encoding encoding, XmlDictionaryReaderQuotas quotas, OnXmlDictionaryReaderClose onClose) 666XmlExceptionHelper.ThrowTokenExpected(this, "?>", Encoding.UTF8.GetString(buffer, offset, 2)); 1077XmlExceptionHelper.ThrowTokenExpected(this, "[CDATA[", Encoding.UTF8.GetString(buffer, offset, 7));

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

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

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

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

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

15internal static readonly Encoding Utf8WithoutPreamble = Encoding.UTF8;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

143public Encoding TextEncoding

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

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

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

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

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

140Encoding encoding = CanonicalFormWriter.Utf8WithoutPreamble;

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

128public Encoding TextEncoding

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

132public System.Text.Encoding TextEncoding

Metadata\MetadaExchangeResolver.cs (3)

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

Metadata\ServiceDescriptor.cs (3)

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

Internal\SecretsStore.cs (1)

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

Internal\SetCommand.cs (1)

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

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

CustomTextMessageEncoder.cs (1)

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

TextTests.4.1.0.cs (2)

32CustomBinding binding = new CustomBinding(new CustomTextMessageBindingElement(Encoding.UTF8.WebName), 75CustomBinding 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 (3)

StringInputFormatter.cs (3)

16SupportedEncodings.Add(Encoding.UTF8); 17SupportedEncodings.Add(Encoding.Unicode); 20public override async Task<InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context, Encoding effectiveEncoding)

GenerateDocumentationAndConfigFiles (1)

Program.cs (1)

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

GetDocument.Insider (2)

Commands\GetDocumentCommandWorker.cs (1)

33private static readonly Encoding _utf8EncodingWithoutBOM

ProgramBase.cs (1)

28Console.OutputEncoding = Encoding.UTF8;

http2cat (29)

Program.cs (1)

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

src\Shared\Http2cat\Http2Utilities.cs (5)

34private static readonly Encoding HeaderValueEncoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true); 120public static readonly byte[] _helloBytes = Encoding.ASCII.GetBytes("hello"); 121public static readonly byte[] _worldBytes = Encoding.ASCII.GetBytes("world"); 122public static readonly byte[] _helloWorldBytes = Encoding.ASCII.GetBytes("hello, world"); 124public static readonly byte[] _maxData = Encoding.ASCII.GetBytes(new string('a', Http2PeerSettings.MinAllowedMaxFrameSize));

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

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

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

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

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

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

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

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

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

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

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

HttpStress (2)

Program.cs (2)

271using (var req = new HttpRequestMessage(HttpMethod.Post, serverUri + "/duplexSlow") { Version = httpVersion, Content = new ByteAtATimeNoLengthContent(Encoding.ASCII.GetBytes(content)) }) 694public StringDuplexContent(string value) => _data = Encoding.UTF8.GetBytes(value);

IdeCoreBenchmarks (1)

ProjectOperationBenchmarks.cs (1)

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

IIS.Common.TestLib (6)

TestConnections.cs (6)

66var bytes = Encoding.ASCII.GetBytes(string.Join("\r\n", lines)); 112Assert.Equal(expected, Encoding.ASCII.GetString((await ReceiveChunk()).Span)); 120Assert.Equal(expected, Encoding.ASCII.GetString(actual.Span)); 151$"Actual:{Environment.NewLine}{Encoding.ASCII.GetString(actual, 0, offset)}{Environment.NewLine}", 186var actualLine = Encoding.ASCII.GetString(actual, 0, offset); 234$"Expected connection close, received data instead: \"{Encoding.ASCII.GetString(e.Buffer, 0, e.BytesTransferred)}\""));

IIS.FunctionalTests (40)

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

162await h2Connection.SendDataAsync(1, Encoding.UTF8.GetBytes("Hello World"), endStream: true); 190Assert.Equal("Hello World", Encoding.UTF8.GetString(dataFrame.Payload.Span)); 231await h2Connection.SendDataAsync(1, Encoding.UTF8.GetBytes("Hello World"), endStream: true); 259Assert.Equal("Hello World", Encoding.UTF8.GetString(dataFrame.Payload.Span)); 304Assert.Equal("Hello World", Encoding.UTF8.GetString(dataFrame.Payload.Span));

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

99return (status, Encoding.UTF8.GetString(bytes0.Span)); 103return (status, Encoding.ASCII.GetString(bytes1.Span));

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

807return (status, Encoding.UTF8.GetString(bytes0.Span)); 811return (status, Encoding.ASCII.GetString(bytes1.Span));

src\Servers\IIS\IIS\test\Common.FunctionalTests\WebSocketTests.cs (3)

184var requestBytes = Encoding.ASCII.GetBytes(builder.ToString()); 190await webSocket.SendAsync(new ArraySegment<byte>(Encoding.ASCII.GetBytes(message)), WebSocketMessageType.Text, true, default); 206Assert.Equal(expectedMessage, Encoding.ASCII.GetString(received));

src\Shared\Http2cat\Http2Utilities.cs (5)

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

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

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

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

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

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

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

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

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

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

IIS.LongTests (28)

src\Shared\Http2cat\Http2Utilities.cs (5)

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

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

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

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

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

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

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

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

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

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

IIS.Microbenchmarks (1)

PlaintextBenchmark.cs (1)

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

IIS.NewHandler.FunctionalTests (28)

src\Shared\Http2cat\Http2Utilities.cs (5)

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

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

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

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

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

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

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

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

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

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

IIS.NewShim.FunctionalTests (28)

src\Shared\Http2cat\Http2Utilities.cs (5)

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

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

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

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

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

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

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

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

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

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

IIS.ShadowCopy.Tests (6)

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

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

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

IISExpress.FunctionalTests (40)

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

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

99return (status, Encoding.UTF8.GetString(bytes0.Span)); 103return (status, Encoding.ASCII.GetString(bytes1.Span));

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

807return (status, Encoding.UTF8.GetString(bytes0.Span)); 811return (status, Encoding.ASCII.GetString(bytes1.Span));

src\Servers\IIS\IIS\test\Common.FunctionalTests\WebSocketTests.cs (3)

src\Shared\Http2cat\Http2Utilities.cs (5)

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

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

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

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

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

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

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

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

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

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

illink (2)

Linker\CustomSymbolWriter.cs (2)

75 writer.Write (Encoding.UTF8.GetBytes (GetOriginalPdbPath ())); 105 return Encoding.UTF8.GetString (

Infrastructure.Common (2)

SafeKeychainHandle.cs (2)

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

InMemory.FunctionalTests (270)

ChunkedRequestTests.cs (9)

ChunkedResponseTests.cs (36)

ConnectionMiddlewareTests.cs (2)

309await context.Response.BodyWriter.WriteAsync(Encoding.ASCII.GetBytes("Hello ")); 311await context.Response.BodyWriter.WriteAsync(Encoding.ASCII.GetBytes("World!"));

Http2\Http2ConnectionTests.cs (10)

Http2\Http2StreamTests.cs (61)

Http2\Http2TestBase.cs (4)

109protected static readonly byte[] _helloBytes = Encoding.ASCII.GetBytes("hello"); 110protected static readonly byte[] _worldBytes = Encoding.ASCII.GetBytes("world"); 111protected static readonly byte[] _helloWorldBytes = Encoding.ASCII.GetBytes("hello, world"); 113protected static readonly byte[] _maxData = Encoding.ASCII.GetBytes(new string('a', Http2PeerSettings.MinAllowedMaxFrameSize));

Http3\Http3ConnectionTests.cs (10)

63await requestStream.SendDataAsync(Encoding.ASCII.GetBytes("Hello world"), endStream: true); 70Assert.Equal("Hello world", Encoding.ASCII.GetString(responseData.ToArray())); 108await requestStream.SendDataAsync(Encoding.ASCII.GetBytes("Hello world"), endStream: false); 113Assert.Equal("Hello world", Encoding.ASCII.GetString(responseData.ToArray())); 117await requestStream.SendDataAsync(Encoding.ASCII.GetBytes($"End"), endStream: true); 119Assert.Equal($"End", Encoding.ASCII.GetString(responseData.ToArray())); 818await requestStream.SendDataAsync(Encoding.ASCII.GetBytes($"Hello world {index}")); 826Assert.Equal($"Hello world {index}", Encoding.ASCII.GetString(responseData.ToArray())); 830await requestStream.SendDataAsync(Encoding.ASCII.GetBytes($"End {index}"), endStream: true); 832Assert.Equal($"End {index}", Encoding.ASCII.GetString(responseData.ToArray()));

Http3\Http3StreamTests.cs (41)

Http3\Http3TestBase.cs (2)

21protected static readonly byte[] _helloWorldBytes = Encoding.ASCII.GetBytes("hello, world"); 22protected static readonly byte[] _maxData = Encoding.ASCII.GetBytes(new string('a', 16 * 1024));

HttpProtocolSelectionTests.cs (2)

55Encoding.ASCII.GetString(Http2Connection.ClientPreface), 56Encoding.ASCII.GetString(expected));

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

HttpsTests.cs (2)

261var request = Encoding.ASCII.GetBytes("GET / HTTP/1.1\r\nHost:\r\n\r\n"); 305var request = Encoding.ASCII.GetBytes("GET / HTTP/1.1\r\nHost:\r\n\r\n");

KeepAliveTimeoutTests.cs (1)

262var responseBytes = Encoding.ASCII.GetBytes("hello, world");

KestrelMetricsTests.cs (1)

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

MaxRequestBodySizeTests.cs (1)

480Assert.Equal("Hello World", Encoding.ASCII.GetString(buffer));

RequestTests.cs (16)

ResponseHeaderTests.cs (5)

50testContext.ServerOptions.ResponseHeaderEncodingSelector = _ => Encoding.UTF8; 63using var connection = server.CreateConnection(Encoding.UTF8); 85var encoding = Encoding.GetEncoding(Encoding.Latin1.CodePage, EncoderFallback.ExceptionFallback,

ResponseTests.cs (48)

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

126var valueEncoding =

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

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

src\Servers\Kestrel\shared\test\Http3\Http3InMemory.cs (2)

35protected static readonly byte[] _helloWorldBytes = Encoding.ASCII.GetBytes("hello, world"); 36protected static readonly byte[] _maxData = Encoding.ASCII.GetBytes(new string('a', 16 * 1024));

src\Servers\Kestrel\shared\test\StreamBackedTestConnection.cs (4)

23protected StreamBackedTestConnection(Stream stream, Encoding encoding = null) 26_reader = new StreamReader(_stream, encoding ?? Encoding.ASCII); 71var writer = new StreamWriter(_stream, Encoding.GetEncoding("iso-8859-1")); 80var writer = new StreamWriter(_stream, Encoding.GetEncoding("iso-8859-1"));

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

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

TestTransport\InMemoryConnection.cs (1)

13public InMemoryConnection(InMemoryTransportConnection transportConnection, Encoding encoding)

TestTransport\InMemoryHttpClientSlim.cs (3)

37using (var writer = new StreamWriter(stream, Encoding.ASCII, bufferSize: 1024, leaveOpen: true)) 76using (var writer = new StreamWriter(stream, Encoding.ASCII, bufferSize: 1024, leaveOpen: true)) 93using (var reader = new StreamReader(stream, Encoding.ASCII, detectEncodingFromByteOrderMarks: true,

TestTransport\TestServer.cs (1)

116public InMemoryConnection CreateConnection(Encoding encoding = null, Action<IFeatureCollection> featuresAction = null)

TlsListenerMiddlewareTests.cs (1)

60var request = Encoding.ASCII.GetBytes("GET / HTTP/1.1\r\nHost:\r\n\r\n");

InProcessWebSite (10)

src\Servers\IIS\IIS\test\testassets\InProcessWebSite\Program.cs (1)

82Console.OutputEncoding = Encoding.UTF8;

src\Servers\IIS\IIS\test\testassets\InProcessWebSite\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);

src\Servers\IIS\IIS\test\testassets\InProcessWebSite\Startup.WebSockets.cs (2)

138await webSocket.SendAsync(new ArraySegment<byte>(Encoding.ASCII.GetBytes(message)), WebSocketMessageType.Text, true, CancellationToken.None); 174Encoding.ASCII.GetString(buffer).Substring(0, result.Count) == closeFromServerCmd)

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

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

Interop.FunctionalTests (8)

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)

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

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

Program.cs (1)

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

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

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

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)

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

Metrics.Legacy (4)

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

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

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

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

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)

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

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

FacebookHandler.cs (2)

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

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

src\Tools\Shared\TestHelpers\TestConsole.cs (2)

83public override Encoding Encoding => Encoding.Unicode;

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

CookieTests.cs (1)

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

FacebookTests.cs (3)

337res.Content = new StringContent(graphResponse, Encoding.UTF8); 346res.Content = new StringContent(graphResponse, Encoding.UTF8); 482res.Content = new StringContent(text, Encoding.UTF8, "application/json");

GoogleTests.cs (1)

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

JwtBearerTests.cs (5)

50var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(new string('a', 128))); 87var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(new string('a', 128))); 919var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(new string('a', 128))); 964var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(new string('a', 128))); 1276var 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))); 1343var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(new string('a', 128)));

MicrosoftAccountTests.cs (1)

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

OAuthTests.cs (1)

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

OpenIdConnect\OpenIdConnectChallengeTests.cs (3)

979new StringContent("{ \"id_token\": \"my_id_token\", \"access_token\": \"my_access_token\" }", Encoding.ASCII, "application/json") 984return new HttpResponseMessage() { Content = new StringContent("{ }", Encoding.ASCII, "application/json") }; 994return new HttpResponseMessage() { Content = new StringContent("{ \"request_uri\": \"my_reference_value\", \"expires_in\": 60}", Encoding.ASCII, "application/json") };

OpenIdConnect\OpenIdConnectEventTests.cs (3)

1314new StringContent(form, Encoding.ASCII, "application/x-www-form-urlencoded")); 1398new StringContent("{ \"id_token\": \"my_id_token\", \"access_token\": \"my_access_token\" }", Encoding.ASCII, "application/json") 1403return Task.FromResult(new HttpResponseMessage() { Content = new StringContent("{ }", Encoding.ASCII, "application/json") });

OpenIdConnect\OpenIdConnectEventTests_Handler.cs (3)

1312new StringContent(form, Encoding.ASCII, "application/x-www-form-urlencoded")); 1393new StringContent("{ \"id_token\": \"my_id_token\", \"access_token\": \"my_access_token\" }", Encoding.ASCII, "application/json") 1398return Task.FromResult(new HttpResponseMessage() { Content = new StringContent("{ }", Encoding.ASCII, "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)

486res.Content = new StringContent(graphResponse, Encoding.UTF8); 600Encoding.UTF8, 615Encoding.UTF8, 630Encoding.UTF8,

WsFederation\CustomStateDataFormat.cs (1)

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

WsFederation\WsFederationTest.cs (1)

453var 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.Authentication.Twitter (2)

TwitterHandler.cs (2)

346var key = Encoding.ASCII.GetBytes( 351var hash = HMACSHA1.HashData(key, Encoding.ASCII.GetBytes(signatureData));

Microsoft.AspNetCore.Components (5)

PersistentState\PersistentServicesRegistry.cs (1)

214var input = Encoding.UTF8.GetBytes(string.Join(".", assemblyName, typeName, propertyName));

Routing\RouteContext.cs (2)

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

SupplyParameterFromPersistentComponentStateValueProvider.cs (2)

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

Microsoft.AspNetCore.Components.Endpoints (12)

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)

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

Rendering\Buffering\BufferedTextWriter.cs (2)

23public override Encoding Encoding => Encoding.UTF8;

Rendering\EndpointHtmlRenderer.EventDispatch.cs (2)

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

Rendering\EndpointHtmlRenderer.Streaming.cs (1)

102var 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(expectedString1, 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 (4)

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

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

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

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)

53var bytes = Encoding.UTF8.GetBytes(msg); 54var bytesWithHeader = Encoding.UTF8.GetBytes($"{bytes.Length}:").Concat(bytes).ToArray(); 73$"after reading {bytesRead} bytes. Instead got: {Encoding.UTF8.GetString(_lengthBuffer)}"); 79string str = Encoding.UTF8.GetString(_lengthBuffer, 0, bytesRead - 1); 94var 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.DeveloperCertificates.XPlat (5)

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

Microsoft.AspNetCore.DeveloperCertificates.XPlat.Tests (4)

CertificateManagerTests.cs (4)

189Assert.Equal("plaintext", Encoding.ASCII.GetString(exportedCertificate.GetRSAPrivateKey().Decrypt(exportedCertificate.GetRSAPrivateKey().Encrypt(Encoding.ASCII.GetBytes(message), RSAEncryptionPadding.OaepSHA256), RSAEncryptionPadding.OaepSHA256))); 351Assert.Equal("plaintext", Encoding.ASCII.GetString(exportedCertificate.GetRSAPrivateKey().Decrypt(exportedCertificate.GetRSAPrivateKey().Encrypt(Encoding.ASCII.GetBytes(message), RSAEncryptionPadding.OaepSHA256), RSAEncryptionPadding.OaepSHA256)));

Microsoft.AspNetCore.Diagnostics (2)

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

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

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

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

Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore (2)

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

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

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

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

Internal\JsonRequestHelpers.cs (9)

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

Internal\JsonTranscodingServerCallContext.cs (3)

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

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

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

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

ConverterTests\JsonConverterWriteTests.cs (1)

191BytesValue = ByteString.CopyFrom(Encoding.UTF8.GetBytes("Hello world")),

ServerStreamingServerCallHandlerTests.cs (3)

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

TestObjects\Services\HttpBodyService.cs (1)

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

UnaryServerCallHandlerTests.cs (15)

Microsoft.AspNetCore.Hosting (1)

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

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

Microsoft.AspNetCore.Http (6)

Features\FormFeature.cs (4)

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

src\Shared\HttpRuleParser.cs (2)

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

Microsoft.AspNetCore.Http.Abstractions (7)

Extensions\HttpResponseWritingExtensions.cs (7)

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

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

HttpResponseWritingExtensionsTests.cs (10)

31public async Task WritingTextThatRequiresMultipleSegmentsWorks(Encoding encoding) 52public async Task WritingTextWithPassedInEncodingWorks(Encoding encoding) 71public static TheoryData<Encoding> Encodings => 72new TheoryData<Encoding> 74{ Encoding.ASCII }, 75{ Encoding.BigEndianUnicode }, 76{ Encoding.Unicode }, 77{ Encoding.UTF32 }, 79{ Encoding.UTF7 }, 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.Common (1)

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

31public override Encoding Encoding => _utf8NoBom;

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

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

76await connection.Transport.Output.WriteAsync(Encoding.ASCII.GetBytes("Hello")); 79Assert.Equal(":\r\ndata: Hello\r\n\r\n", Encoding.ASCII.GetString(ms.ToArray())); 101await connection.Transport.Output.WriteAsync(Encoding.ASCII.GetBytes(hText + wText)); 104Assert.Equal(":\r\ndata: " + hText + wText + "\r\n\r\n", Encoding.ASCII.GetString(ms.ToArray())); 124await connection.Transport.Output.WriteAsync(Encoding.UTF8.GetBytes(message)); 130Assert.Equal(expected, Encoding.UTF8.GetString(ms.ToArray()));

src\Shared\Buffers.Testing\ReadOnlySequenceFactory.cs (1)

24return CreateWithContent(Encoding.ASCII.GetBytes(data));

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

HttpRequestJsonExtensions.cs (12)

70var encoding = GetEncodingFromCharset(charset); 108var encoding = GetEncodingFromCharset(charset); 146var encoding = GetEncodingFromCharset(charset); 208var encoding = GetEncodingFromCharset(charset); 250var encoding = GetEncodingFromCharset(charset); 315private static (Stream inputStream, bool usesTranscodingStream) GetInputStream(HttpContext httpContext, Encoding? encoding) 317if (encoding == null || encoding.CodePage == Encoding.UTF8.CodePage) 322var inputStream = Encoding.CreateTranscodingStream(httpContext.Request.Body, encoding, Encoding.UTF8, leaveOpen: true); 326private static Encoding? GetEncodingFromCharset(StringSegment charset) 332return Encoding.UTF8; 338return charset.HasValue ? Encoding.GetEncoding(charset.Value) : null;

SessionExtensions.cs (2)

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

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

HttpRequestJsonExtensionsTests.cs (9)

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

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

ValidationsGenerator\ValidationsGeneratorTestBase.cs (3)

130var encoding = text.Encoding ?? Encoding.UTF8; 570var stream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(requestData));

Microsoft.AspNetCore.Http.Microbenchmarks (4)

RequestDelegateGeneratorBenchmarks.cs (1)

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

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

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

Microsoft.AspNetCore.Http.Results (25)

HttpResultsHelper.cs (3)

20private static readonly Encoding DefaultEncoding = Encoding.UTF8; 76out var resolvedContentTypeEncoding);

Results.cs (8)

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

src\Shared\ResponseContentTypeHelper.cs (6)

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

TypedResults.cs (8)

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

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

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

ContentResultTests.cs (2)

20Encoding = Encoding.Unicode 62new MediaTypeHeaderValue("text/foo") { Encoding = Encoding.ASCII },

CreatedOfTResultTests.cs (1)

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

InternalServerErrorOfTResultTests.cs (1)

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

JsonResultTests.cs (2)

72Assert.Equal("\"Hello\"", Encoding.UTF8.GetString(stream.ToArray())); 109Assert.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 (8)

541var encoding = Encoding.UTF8; 558var encoding = Encoding.UTF8; 1645var encoding = Encoding.ASCII; 1664var encoding = Encoding.ASCII;

ServerSentEventsResultTests.cs (11)

src\Shared\ResultsTests\FileContentResultTestBase.cs (8)

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

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

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

TypedResultsTests.cs (8)

537var encoding = Encoding.UTF8; 554var encoding = Encoding.UTF8; 1424var encoding = Encoding.ASCII; 1443var encoding = Encoding.ASCII;

UnprocessableEntityOfTResultTests.cs (1)

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

Microsoft.AspNetCore.Http.Tests (32)

Features\FormFeatureTests.cs (29)

Features\RequestBodyPipeFeatureTests.cs (3)

31context.Request.Body = new MemoryStream(Encoding.ASCII.GetBytes("hahaha")); 36context.Request.Body = new MemoryStream(Encoding.ASCII.GetBytes(expectedString)); 67return Encoding.ASCII.GetString(data.Buffer.ToArray());

Microsoft.AspNetCore.Http.ValidationsGenerator (1)

Emitters\ValidationsGenerator.Emitter.cs (1)

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

Microsoft.AspNetCore.HttpLogging (20)

BufferingStream.cs (1)

50public string GetString(Encoding encoding)

HttpLoggingMiddleware.cs (1)

161out var encoding))

MediaTypeHelpers.cs (7)

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

MediaTypeOptions.cs (8)

25options.AddText("application/json", Encoding.UTF8); 26options.AddText("application/*+json", Encoding.UTF8); 27options.AddText("application/xml", Encoding.UTF8); 28options.AddText("application/*+xml", Encoding.UTF8); 29options.AddText("text/*", Encoding.UTF8); 38mediaType.Encoding ??= Encoding.UTF8; 62public void AddText(string contentType, Encoding encoding) 108public Encoding? Encoding { get; init; }

RequestBufferingStream.cs (2)

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

ResponseBufferingStream.cs (1)

22private Encoding? _encoding;

Microsoft.AspNetCore.HttpLogging.Tests (21)

HttpLoggingMiddlewareTests.cs (21)

Microsoft.AspNetCore.Identity (5)

DataProtectorTokenProvider.cs (1)

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

IdentityApiEndpointRouteBuilderExtensions.cs (4)

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

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

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

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

Microsoft.AspNetCore.Identity.FunctionalTests (1)

src\Identity\Extensions.Core\src\Rfc6238AuthenticationService.cs (1)

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

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)

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

Microsoft.AspNetCore.Identity.Test (1)

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

75return 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.InternalTesting (3)

HttpClientSlim.cs (3)

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

Microsoft.AspNetCore.InternalTesting.Tests (1)

HttpClientSlimTest.cs (1)

15private static readonly byte[] _defaultResponse = Encoding.ASCII.GetBytes("test");

Microsoft.AspNetCore.Mvc.Abstractions (5)

Formatters\InputFormatterContext.cs (3)

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

Formatters\OutputFormatterWriteContext.cs (2)

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

Microsoft.AspNetCore.Mvc.ApiExplorer.Test (1)

DefaultApiDescriptionProviderTest.cs (1)

2843Encoding effectiveEncoding)

Microsoft.AspNetCore.Mvc.Core (82)

ControllerBase.cs (1)

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

Formatters\MediaType.cs (7)

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

Formatters\StringOutputFormatter.cs (3)

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

Formatters\SystemTextJsonInputFormatter.cs (5)

55Encoding encoding) 126private static (Stream inputStream, bool usesTranscodingStream) GetInputStream(HttpContext httpContext, Encoding encoding) 128if (encoding.CodePage == Encoding.UTF8.CodePage) 133var inputStream = Encoding.CreateTranscodingStream(httpContext.Request.Body, encoding, Encoding.UTF8, leaveOpen: true);

Formatters\SystemTextJsonOutputFormatter.cs (6)

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

Formatters\TextInputFormatter.cs (11)

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

Formatters\TextOutputFormatter.cs (16)

25SupportedEncodings = new List<Encoding>(); 33public IList<Encoding> SupportedEncodings { get; } 44cache.Add(mediaType, MediaType.ReplaceEncoding(mediaType, Encoding.UTF8)); 57/// Determines the best <see cref="Encoding"/> amongst the supported encodings 62/// <returns>The <see cref="Encoding"/> to use when reading the request or writing the response.</returns> 63public virtual Encoding SelectCharacterEncoding(OutputFormatterWriteContext context) 75var encoding = MatchAcceptCharacterEncoding(acceptCharsetHeaderValues); 89var supportedEncoding = SupportedEncodings[i]; 121var selectedEncoding = SelectCharacterEncoding(context); 157$"{nameof(WriteResponseBodyAsync)}({nameof(OutputFormatterWriteContext)},{nameof(Encoding)})"); 166/// <param name="selectedEncoding">The <see cref="Encoding"/> that should be used to write the response.</param> 168public abstract Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding); 181private string GetMediaTypeWithCharset(string mediaType, Encoding encoding) 183if (string.Equals(encoding.WebName, Encoding.UTF8.WebName, StringComparison.OrdinalIgnoreCase) && 192private Encoding? MatchAcceptCharacterEncoding(IList<StringWithQualityHeaderValue> acceptCharsetHeaders) 204var encoding = SupportedEncodings[j];

Infrastructure\ContentResultExecutor.cs (2)

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

Infrastructure\IHttpRequestStreamReaderFactory.cs (3)

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

Infrastructure\IHttpResponseStreamWriterFactory.cs (3)

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

Infrastructure\MemoryPoolHttpRequestStreamReaderFactory.cs (1)

46public TextReader CreateReader(Stream stream, Encoding encoding)

Infrastructure\MemoryPoolHttpResponseStreamWriterFactory.cs (1)

54public TextWriter CreateWriter(Stream stream, Encoding encoding)

Infrastructure\ObjectResultExecutor.cs (1)

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

Infrastructure\SystemTextJsonResultExecutor.cs (6)

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

ModelBinding\Binders\BodyModelBinder.cs (1)

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

src\Shared\HttpRuleParser.cs (2)

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

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

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

src\Shared\ResponseContentTypeHelper.cs (6)

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

ContentResultTest.cs (3)

32Encoding = Encoding.Unicode 74new MediaTypeHeaderValue("text/foo") { Encoding = Encoding.ASCII }, 234var encoding = MediaTypeHeaderValue.Parse(contentType).Encoding;

ControllerBaseTest.cs (3)

2217var actualContentResult = controller.Content("TestContent", "text/plain", Encoding.UTF8); 2222Assert.Same(Encoding.UTF8, MediaType.GetEncoding(actualContentResult.ContentType)); 3311return Content("Hello!!", "text/xml; charset=invalid; p1=p1-value", Encoding.ASCII);

Formatters\FormatterCollectionTest.cs (2)

50public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) 58public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding)

Formatters\JsonInputFormatterTestBase.cs (23)

Formatters\JsonOutputFormatterTestBase.cs (10)

86var encoding = CreateOrGetSupportedEncoding(formatter, encodingAsString, isDefaultEncoding); 101await formatter.WriteResponseBodyAsync(outputFormatterContext, Encoding.GetEncoding(encodingAsString)); 118var encoding = CreateOrGetSupportedEncoding(formatter, "utf-8", isDefaultEncoding: true); 133await formatter.WriteResponseBodyAsync(outputFormatterContext, Encoding.GetEncoding("utf-8")); 150await Record.ExceptionAsync(() => jsonFormatter.WriteResponseBodyAsync(outputFormatterContext, Encoding.UTF8)); 158var content = new StreamReader(body, Encoding.UTF8).ReadToEnd(); 179Func<Stream, Encoding, TextWriter> writerFactory = null) 194protected static Encoding CreateOrGetSupportedEncoding( 199Encoding encoding = null; 208encoding = Encoding.GetEncoding(encodingAsString);

Formatters\MediaTypeTest.cs (2)

139var encoding = Encoding.GetEncoding("iso-8859-1");

Formatters\ResponseContentTypeHelperTest.cs (3)

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

Formatters\StringOutputFormatterTests.cs (2)

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

40var encoding = CreateOrGetSupportedEncoding(formatter, "utf-8", isDefaultEncoding: true); 55await formatter.WriteResponseBodyAsync(outputFormatterContext, Encoding.GetEncoding("utf-8")); 68var encoding = CreateOrGetSupportedEncoding(formatter, "utf-16", isDefaultEncoding: true); 83await Assert.ThrowsAsync<TimeZoneNotFoundException>(() => formatter.WriteResponseBodyAsync(outputFormatterContext, Encoding.GetEncoding("utf-16"))); 94var encoding = CreateOrGetSupportedEncoding(formatter, "utf-8", isDefaultEncoding: true); 110await formatter.WriteResponseBodyAsync(outputFormatterContext, Encoding.GetEncoding("utf-8")); 140await formatter.WriteResponseBodyAsync(outputFormatterContext, Encoding.GetEncoding("utf-8")); 186var encoding = CreateOrGetSupportedEncoding(formatter, "utf-8", isDefaultEncoding: true); 201await formatter.WriteResponseBodyAsync(outputFormatterContext, Encoding.GetEncoding("utf-8")); 226var encoding = CreateOrGetSupportedEncoding(formatter, "utf-8", isDefaultEncoding: true); 241await formatter.WriteResponseBodyAsync(outputFormatterContext, Encoding.GetEncoding("utf-8"));

Formatters\TextInputFormatterTest.cs (21)

Formatters\TextOutputFormatterTests.cs (12)

50formatter.SupportedEncodings.Add(Encoding.GetEncoding(supportedEncoding)); 63var actualEncoding = formatter.SelectCharacterEncoding(context); 66Assert.Equal(Encoding.GetEncoding(expectedEncoding), actualEncoding); 77var formatter = new OverrideEncodingFormatter(Encoding.UTF32); 111formatter.SupportedEncodings.Add(Encoding.UTF8); 142formatter.SupportedEncodings.Add(Encoding.UTF8); 168formatter.SupportedEncodings.Add(Encoding.Unicode); 264public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) 272private readonly Encoding _encoding; 274public OverrideEncodingFormatter(Encoding encoding) 279public override Encoding SelectCharacterEncoding(OutputFormatterWriteContext context) 284public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding)

Infrastructure\DefaultOutputFormatterSelectorTest.cs (6)

399SupportedEncodings.Add(Encoding.UTF8); 402public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) 415SupportedEncodings.Add(Encoding.UTF8); 418public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) 430SupportedEncodings.Add(Encoding.UTF8); 433public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding)

Infrastructure\JsonResultExecutorTestBase.cs (12)

Infrastructure\ObjectResultExecutorTest.cs (6)

506SupportedEncodings.Add(Encoding.UTF8); 511public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) 526SupportedEncodings.Add(Encoding.UTF8); 529public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) 541SupportedEncodings.Add(Encoding.UTF8); 544public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding)

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

ModelBinding\Validation\DefaultObjectValidatorTests.cs (1)

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

src\Shared\ResultsTests\FileContentResultTestBase.cs (8)

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

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

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

Microsoft.AspNetCore.Mvc.Core.TestCommon (2)

TestHttpRequestStreamReaderFactory.cs (1)

12public TextReader CreateReader(Stream stream, Encoding encoding)

TestHttpResponseStreamWriterFactory.cs (1)

14public TextWriter CreateWriter(Stream stream, Encoding encoding)

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

XmlDataContractSerializerInputFormatter.cs (3)

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

XmlDataContractSerializerOutputFormatter.cs (3)

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

XmlSerializerInputFormatter.cs (5)

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

XmlSerializerOutputFormatter.cs (3)

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

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

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

XmlDataContractSerializerOutputFormatterTest.cs (3)

738await formatter.WriteResponseBodyAsync(outputFormatterContext, Encoding.GetEncoding("utf-8")); 775await formatter.WriteResponseBodyAsync(outputFormatterContext, Encoding.GetEncoding("utf-8")); 778Assert.Contains("<int>1</int><int>2</int>", Encoding.UTF8.GetString(body.ToArray()));

XmlSerializerInputFormatterTest.cs (23)

XmlSerializerOutputFormatterTest.cs (3)

520await formatter.WriteResponseBodyAsync(outputFormatterContext, Encoding.GetEncoding("utf-8")); 557await formatter.WriteResponseBodyAsync(outputFormatterContext, Encoding.GetEncoding("utf-8")); 560Assert.Contains("<int>1</int><int>2</int>", Encoding.UTF8.GetString(body.ToArray()));

Microsoft.AspNetCore.Mvc.FunctionalTests (50)

ApiBehaviorTest.cs (2)

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

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

45var content = new StringContent(input, Encoding.UTF8, "application/xml"); 61var content = new StringContent("Test Content", Encoding.GetEncoding(encoding), "text/plain"); 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 (43)

BindingSourceMetadataProviderIntegrationTest.cs (1)

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

BodyValidationIntegrationTests.cs (19)

ComplexRecordIntegrationTest.cs (2)

22private static readonly byte[] ByteArrayContent = Encoding.BigEndianUnicode.GetBytes("abcd"); 4229var memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(content));

ComplexTypeIntegrationTestBase.cs (2)

23private static readonly byte[] ByteArrayContent = Encoding.BigEndianUnicode.GetBytes("abcd"); 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 (14)

NewtonsoftJsonInputFormatter.cs (1)

96Encoding encoding)

NewtonsoftJsonOutputFormatter.cs (3)

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

NewtonsoftJsonPatchInputFormatter.cs (1)

63Encoding encoding)

NewtonsoftJsonResultExecutor.cs (3)

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

src\Shared\ResponseContentTypeHelper.cs (6)

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

JsonResultTest.cs (1)

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

NewtonsoftJsonInputFormatterTest.cs (14)

38var contentBytes = Encoding.UTF8.GetBytes(content); 74var contentBytes = Encoding.UTF8.GetBytes(content); 110var contentBytes = Encoding.UTF8.GetBytes(content); 160var contentBytes = Encoding.UTF8.GetBytes("{ \"UserName\" : \"John\"}"); 237var contentBytes = Encoding.UTF8.GetBytes(content); 262var contentBytes = Encoding.UTF8.GetBytes(content); 292var contentBytes = Encoding.UTF8.GetBytes("{"); 325var contentBytes = Encoding.UTF8.GetBytes("{"); 357var contentBytes = Encoding.UTF8.GetBytes("{\"dateValue\":\"not-a-date\"}"); 388var contentBytes = Encoding.UTF8.GetBytes("{\"ShortValue\":\"32768\"}"); 419var contentBytes = Encoding.UTF8.GetBytes("{ \"Complex\": { \"WithPrimitives\": [ { \"ShortValue\":\"32768\" } ] } }"); 452var content = Encoding.UTF8.GetBytes("\"Hello world\""); 502var contentBytes = Encoding.UTF8.GetBytes(content); 545var contentBytes = Encoding.UTF8.GetBytes(content);

NewtonsoftJsonOutputFormatterTest.cs (22)

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

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

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

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

PageBase.cs (1)

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

PageModel.cs (1)

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

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

PageModelTest.cs (3)

1602var actualContentResult = pageModel.Content("TestContent", "text/plain", Encoding.UTF8); 1607Assert.Same(Encoding.UTF8, MediaType.GetEncoding(actualContentResult.ContentType)); 2064return Content("Hello!!", "text/xml; charset=invalid; p1=p1-value", Encoding.ASCII);

PageTest.cs (3)

1592var actualContentResult = page.Content("TestContent", "text/plain", Encoding.UTF8); 1597Assert.Same(Encoding.UTF8, MediaType.GetEncoding(actualContentResult.ContentType)); 1907return Content("Hello!!", "text/xml; charset=invalid; p1=p1-value", Encoding.ASCII);

Microsoft.AspNetCore.Mvc.TagHelpers (6)

Cache\CacheTagKey.cs (1)

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

Cache\DistributedCacheTagHelperFormatter.cs (2)

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

Cache\DistributedCacheTagHelperService.cs (1)

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

CacheTagHelper.cs (1)

222public override Encoding Encoding => Null.Encoding;

PartialTagHelper.cs (1)

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

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

Buffers\PagedBufferedTextWriter.cs (1)

22public override Encoding Encoding => _inner.Encoding;

Buffers\ViewBufferTextWriter.cs (5)

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

DefaultEditorTemplates.cs (1)

461public override Encoding Encoding => Null.Encoding;

HtmlHelper.cs (1)

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

ViewComponentResultExecutor.cs (2)

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

ViewExecutor.cs (2)

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

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

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

66var encoding = Encoding.ASCII; 147Assert.Equal(content, Encoding.UTF8.GetString(fileContentResult.FileContents)); 180using (var stream = new StreamReader(fileStreamResult.FileStream, Encoding.UTF8)) 748public IActionResult Content_Action(string content, string contentType, Encoding encoding) 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 (2)

528new MediaTypeHeaderValue("text/foo") { Encoding = Encoding.ASCII }.ToString(), 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 (1)

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

31public override Encoding Encoding => _utf8NoBom;

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

SnapshotTestHelper.cs (4)

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

Microsoft.AspNetCore.OpenApi.Tests (6)

Extensions\OpenApiEndpointRouteBuilderExtensionsTests.cs (4)

102var responseString = Encoding.UTF8.GetString(responseBodyStream.ToArray()); 133Assert.Equal("No OpenAPI document with the name 'v2' was found.", Encoding.UTF8.GetString(responseBodyStream.ToArray())); 182var responseString = Encoding.UTF8.GetString(responseBodyStream.ToArray()); 223var responseString = Encoding.UTF8.GetString(responseBodyStream.ToArray());

Services\OpenApiDocumentServiceTestsBase.cs (2)

106SupportedEncodings.Add(Encoding.UTF8); 109public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding)

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

TagHelpers\DefaultTagHelperContent.cs (2)

305public override Encoding Encoding 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 (9)

src\Shared\HttpRuleParser.cs (2)

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

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

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

Helpers.cs (1)

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

HttpSysOptions.cs (2)

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

RequestProcessing\RequestContext.cs (1)

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

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

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

17private static readonly Encoding UTF8 = new UTF8Encoding(

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

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

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

Http2Tests.cs (4)

193await h2Connection.SendDataAsync(1, Encoding.UTF8.GetBytes("Hello World"), endStream: true); 209Assert.Equal("Hello World", Encoding.UTF8.GetString(dataFrame.Payload.Span)); 257await h2Connection.SendDataAsync(1, Encoding.UTF8.GetBytes("Hello World"), endStream: true); 273Assert.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 (8)

Listener\RequestTests.cs (2)

182byte[] request = Encoding.ASCII.GetBytes(builder.ToString()); 190return Encoding.ASCII.GetString(response);

Listener\ResponseHeaderTests.cs (1)

263var responseBytes = Encoding.ASCII.GetBytes("10\r\nManually Chunked\r\n0\r\n\r\n");

OpaqueUpgradeTests.cs (2)

351var requestBytes = Encoding.ASCII.GetBytes(builder.ToString()); 427return Encoding.ASCII.GetBytes(builder.ToString());

RequestBodyTests.cs (1)

352return Encoding.ASCII.GetBytes(builder.ToString());

RequestHeaderTests.cs (4)

71var request = Encoding.ASCII.GetBytes(builder.ToString()); 78var result = Encoding.ASCII.GetString(response, 0, read); 271byte[] request = Encoding.ASCII.GetBytes(builder.ToString()); 279return Encoding.ASCII.GetString(response, 0, read);

RequestTests.cs (11)

ResponseBodyTests.cs (3)

194var responseBytes = Encoding.ASCII.GetBytes("10\r\nManually Chunked\r\n0\r\n\r\n"); 408var data = Encoding.UTF8.GetBytes("hello, world"); 431Assert.Equal("hello, world", Encoding.UTF8.GetString(payload));

ResponseHeaderTests.cs (2)

128var socketsHttpHandler = new SocketsHttpHandler() { ResponseHeaderEncodingSelector = (_, _) => Encoding.UTF8 }; 193var responseBytes = Encoding.ASCII.GetBytes("10\r\nManually Chunked\r\n0\r\n\r\n");

ResponseTests.cs (1)

264byte[] request = Encoding.ASCII.GetBytes(builder.ToString());

ServerTests.cs (1)

695return Encoding.ASCII.GetBytes(builder.ToString());

src\Shared\Http2cat\Http2Utilities.cs (5)

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

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

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

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

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

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

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

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

Microsoft.AspNetCore.Server.HttpSys.Microbenchmarks (3)

RequestHeaderBenchmarks.cs (3)

73var length = Encoding.ASCII.GetBytes("localhost:5001", dataDestination); 99var nameLength = Encoding.ASCII.GetBytes(headerKey, dataDestination); 109var valueLength = Encoding.ASCII.GetBytes(headerValue, dataDestination);

Microsoft.AspNetCore.Server.HttpSys.Tests (6)

RequestHeaderTests.cs (6)

360int length = Encoding.ASCII.GetBytes("localhost:5001", dataDestination); 369length = Encoding.ASCII.GetBytes("application/json", dataDestination); 384int length = Encoding.ASCII.GetBytes("localhost:5001", dataDestination); 414int nameLength = Encoding.ASCII.GetBytes(headerName.Key, dataDestination); 424int valueLength = Encoding.ASCII.GetBytes(headerName.Value, dataDestination); 454int nameLength = Encoding.ASCII.GetBytes(headerName, dataDestination);

Microsoft.AspNetCore.Server.IIS (15)

Core\IISHttpContext.cs (4)

614var headerValueBytes = Encoding.UTF8.GetBytes(headerValue); 620var headerNameBytes = Encoding.UTF8.GetBytes(headerPair.Key); 647var headerNameBytes = Encoding.ASCII.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);

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

17private static readonly Encoding UTF8 = new UTF8Encoding(

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

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

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

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

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

Microsoft.AspNetCore.Server.IntegrationTesting.IIS (1)

LoggingHandler.cs (1)

49_logger.Log(logLevel, Encoding.ASCII.GetString(buffer, 0, offset));

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

Internal\Http\DateHeaderValueManager.cs (1)

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

Internal\Http\HttpHeaders.cs (1)

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

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

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

Internal\Http\HttpProtocol.cs (4)

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

Internal\Http\HttpRequestHeaders.cs (3)

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

Internal\Http\HttpResponseHeaders.cs (4)

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

Internal\Http\HttpResponseTrailers.cs (2)

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

Internal\Http\PathDecoder.cs (1)

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

Internal\Http\ReasonPhrases.cs (1)

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

Internal\Http2\Http2Connection.cs (1)

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

Internal\Http3\Http3HeadersEnumerator.cs (1)

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

Internal\Http3\QPackHeaderWriter.cs (2)

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

Internal\Infrastructure\HttpUtilities.cs (5)

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

Internal\Infrastructure\KestrelEventSource.cs (2)

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

KestrelServerOptions.cs (7)

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

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

126var valueEncoding =

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ChunkWriterTests.cs (1)

44Assert.Equal(Encoding.ASCII.GetBytes(expected), span.Slice(0, count).ToArray());

Http1\Http1ConnectionTests.cs (37)

Http2\Http2HPackEncoderTests.cs (1)

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

HttpParserTests.cs (33)

HttpRequestHeadersTests.cs (32)

HttpResponseHeadersTests.cs (2)

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

HttpUtilitiesTest.cs (9)

36var block = new ReadOnlySpan<byte>(Encoding.ASCII.GetBytes(input)); 66var block = new ReadOnlySpan<byte>(Encoding.ASCII.GetBytes(input)); 129var knownString1 = action(Encoding.ASCII.GetBytes(input)); 130var knownString2 = action(Encoding.ASCII.GetBytes(input)); 232public static TheoryData<Func<string, Encoding>> ExceptionThrownForCRLFData 236return new TheoryData<Func<string, Encoding>> { 239str => Encoding.Latin1 246private void ExceptionThrownForCRLF(Func<string, Encoding> selector) 255private void ExceptionNotThrownForCRLF(Func<string, Encoding> selector)

KnownStringsTests.cs (18)

MessageBodyTests.cs (4)

1402var encoding = Encoding.ASCII; 1414var encoding = Encoding.ASCII;

PipelineExtensionTests.cs (4)

47var expected = Encoding.ASCII.GetBytes(numAsStr); 64var expected = Encoding.ASCII.GetBytes(numAsStr); 92AssertExtensions.Equal(Encoding.ASCII.GetBytes(numAsString), written.ToArray()); 196AssertExtensions.Equal(Encoding.ASCII.GetBytes(testString), written.ToArray());

ReasonPhrasesTests.cs (2)

22Assert.Equal(expectedResult, Encoding.ASCII.GetString(bytes)); 38Assert.EndsWith(reasonPhrase, Encoding.ASCII.GetString(bytes));

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

126var valueEncoding =

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

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

src\Servers\Kestrel\shared\KnownHeaders.cs (4)

src\Servers\Kestrel\shared\test\StreamBackedTestConnection.cs (4)

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

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

src\Shared\Buffers.Testing\ReadOnlySequenceFactory.cs (1)

24return CreateWithContent(Encoding.ASCII.GetBytes(data));

src\Shared\test\Shared.Tests\runtime\Http2\DynamicTableTest.cs (6)

16private readonly HeaderField _header1 = new HeaderField(staticTableIndex: null, Encoding.ASCII.GetBytes("header-1"), Encoding.ASCII.GetBytes("value1")); 17private readonly HeaderField _header2 = new HeaderField(staticTableIndex: null, Encoding.ASCII.GetBytes("header-02"), Encoding.ASCII.GetBytes("value_2")); 141byte[] data = Encoding.ASCII.GetBytes($"header-{insertedHeaders.Count}"); 174byte[] data = Encoding.ASCII.GetBytes($"header-{dynamicTable.Size}".PadRight(16, ' '));

src\Shared\test\Shared.Tests\runtime\Http2\HPackDecoderTest.cs (25)

src\Shared\test\Shared.Tests\runtime\Http2\HuffmanDecodingTests.cs (14)

src\Shared\test\Shared.Tests\runtime\Http3\QPackDecoderTest.cs (9)

StartLineTests.cs (17)

TestHelpers\TestInput.cs (1)

67var data = Encoding.ASCII.GetBytes(text);

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

DotSegmentRemovalBenchmark.cs (5)

19private readonly byte[] _noDotSegmentsAscii = Encoding.ASCII.GetBytes(_noDotSegments); 20private readonly byte[] _singleDotSegmentsAscii = Encoding.ASCII.GetBytes(_singleDotSegments); 21private readonly byte[] _doubleDotSegmentsAscii = Encoding.ASCII.GetBytes(_doubleDotSegments); 22private readonly byte[] _oneDingleDotSegmentsAscii = Encoding.ASCII.GetBytes(_oneSingleDotSegments); 23private readonly byte[] _oneDoubleDotSegmentsAscii = Encoding.ASCII.GetBytes(_oneDoubleDotSegments);

HeaderCollectionBenchmark.cs (1)

23private static readonly byte[] _bytesServer = Encoding.ASCII.GetBytes("\r\nServer: Kestrel");

Http1ReadingBenchmark.cs (1)

33private readonly byte[] _readData = Encoding.ASCII.GetBytes(new string('a', 100));

Http1WritingBenchmark.cs (1)

33private readonly byte[] _writeData = Encoding.ASCII.GetBytes("Hello, World!");

Http2\HPackDecoderBenchmark.cs (4)

20private static readonly byte[] _headerNameBytes = Encoding.ASCII.GetBytes(_headerNameString); 28private static readonly byte[] _headerValueBytes = Encoding.ASCII.GetBytes(_headerValueString); 49.Concat(Encoding.ASCII.GetBytes(string8193)) 51.Concat(Encoding.ASCII.GetBytes(string8193))

Http2\HPackHeaderWriterBenchmark.cs (2)

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

InMemoryTransportBenchmark.cs (2)

71var response = Encoding.ASCII.GetString(await _connection.GetResponseAsync(expectedResponse.Length)); 240private static readonly byte[] _helloWorldPayload = Encoding.UTF8.GetBytes("Hello, World!");

KnownStringsBenchmark.cs (10)

Mocks\NullParser.cs (7)

14private readonly byte[] _startLine = Encoding.ASCII.GetBytes("GET /plaintext HTTP/1.1\r\n"); 15private readonly byte[] _hostHeaderName = Encoding.ASCII.GetBytes("Host"); 16private readonly byte[] _hostHeaderValue = Encoding.ASCII.GetBytes("www.example.com"); 17private readonly byte[] _acceptHeaderName = Encoding.ASCII.GetBytes("Accept"); 18private readonly byte[] _acceptHeaderValue = Encoding.ASCII.GetBytes("text/plain,text/html;q=0.9,application/xhtml+xml;q=0.9,application/xml;q=0.8,*/*;q=0.7"); 19private readonly byte[] _connectionHeaderName = Encoding.ASCII.GetBytes("Connection"); 20private readonly byte[] _connectionHeaderValue = Encoding.ASCII.GetBytes("keep-alive");

NamedPipesTransportBenchmark.cs (2)

73var response = Encoding.ASCII.GetString(_responseBuffer); 138private static readonly byte[] _helloWorldPayload = Encoding.UTF8.GetBytes("Hello, World!");

RequestParsingData.cs (8)

ResponseHeaderCollectionBenchmark.cs (1)

24private static readonly byte[] _bytesServer = Encoding.ASCII.GetBytes("\r\nServer: Kestrel");

ResponseHeadersWritingBenchmark.cs (2)

23private static readonly byte[] _bytesServer = Encoding.ASCII.GetBytes("\r\nServer: " + Constants.ServerName); 24private static readonly byte[] _helloWorldPayload = Encoding.ASCII.GetBytes("Hello, World!");

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

126var valueEncoding =

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

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

src\Servers\Kestrel\shared\test\Http3\Http3InMemory.cs (2)

35protected static readonly byte[] _helloWorldBytes = Encoding.ASCII.GetBytes("hello, world"); 36protected static readonly byte[] _maxData = Encoding.ASCII.GetBytes(new string('a', 16 * 1024));

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

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

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

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

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

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.Server.Kestrel.Transport.Sockets (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.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 (106)

PathNormalizerTests.cs (2)

82var data = Encoding.ASCII.GetBytes(input); 85Assert.Equal(expected, Encoding.ASCII.GetString(data, 0, length));

runtime\Http2\DynamicTableTest.cs (6)

runtime\Http2\HPackDecoderTest.cs (25)

runtime\Http2\HuffmanDecodingTests.cs (14)

runtime\Http3\QPackDecoderTest.cs (9)

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

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

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

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

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

17private static readonly Encoding UTF8 = new UTF8Encoding(

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

HttpConnectionTests.Transport.cs (9)

70await connection.Transport.Output.WriteAsync(Encoding.UTF8.GetBytes("Hello world 1")); 71await connection.Transport.Output.WriteAsync(Encoding.UTF8.GetBytes("Hello world 2")); 146await connection.Transport.Output.WriteAsync(Encoding.UTF8.GetBytes("Hello World")); 186await connection.Transport.Output.WriteAsync(Encoding.UTF8.GetBytes("Hello World")); 218Assert.Contains("This is a test", Encoding.UTF8.GetString(await connection.Transport.Input.ReadAllAsync())); 410Assert.Equal("This is a test", Encoding.UTF8.GetString(message.Buffer)); 412await connection.Transport.Output.WriteAsync(Encoding.UTF8.GetBytes("Hello world 1")); 507await connection.Transport.Output.WriteAsync(Encoding.UTF8.GetBytes("Hello world 1")); 550await connection.Transport.Output.WriteAsync(Encoding.UTF8.GetBytes("Hello world 1"));

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

85int count = Encoding.ASCII.GetBytes("data: 3:abc\r\n\r\n", data.Span); 108Assert.StartsWith("3:abc", Encoding.ASCII.GetString(message)); 138return new ValueTask<int>(Encoding.ASCII.GetBytes("data: 3:a", data.Span)); 289Assert.Equal("3:abc", Encoding.ASCII.GetString(message)); 490Assert.Equal(expectedMessage, Encoding.ASCII.GetString(message)); 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 (3)

Protocol\HandshakeProtocol.cs (1)

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

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

26_decoder = Encoding.UTF8.GetDecoder();

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

31public override Encoding Encoding => _utf8NoBom;

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

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

src\Shared\Buffers.Testing\ReadOnlySequenceFactory.cs (1)

24return CreateWithContent(Encoding.ASCII.GetBytes(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 (17)

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\":[]}]}");

src\Shared\Buffers.Testing\ReadOnlySequenceFactory.cs (1)

24return CreateWithContent(Encoding.ASCII.GetBytes(data));

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

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

26_decoder = Encoding.UTF8.GetDecoder();

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

31public override Encoding Encoding => _utf8NoBom;

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

Protocol\MessagePackHubProtocolWorker.cs (1)

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

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

Protocol\NewtonsoftJsonHubProtocol.cs (1)

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

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

26_decoder = Encoding.UTF8.GetDecoder();

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

31public override Encoding Encoding => _utf8NoBom;

Microsoft.AspNetCore.SignalR.StackExchangeRedis (2)

RedisHubLifetimeManager.cs (2)

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)

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)

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

Microsoft.AspNetCore.StaticFiles (1)

HtmlDirectoryFormatter.cs (1)

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

Microsoft.AspNetCore.StaticFiles.FunctionalTests (1)

StaticFileMiddlewareTests.cs (1)

300byte[] request = Encoding.ASCII.GetBytes(builder.ToString());

Microsoft.AspNetCore.TestHost.Tests (17)

ClientHandlerTests.cs (2)

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

HttpContextBuilderTests.cs (2)

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

TestClientTests.cs (12)

128var character = Encoding.ASCII.GetBytes("a"); 219Assert.Equal("STARTED", Encoding.UTF8.GetString(buffer, 0, length)); 222await requestStream.WriteAsync(Encoding.UTF8.GetBytes("Hello world")).AsTask().DefaultTimeout(); 228Assert.Equal("Hello world POST Response", Encoding.UTF8.GetString(buffer, 0, length)); 282Assert.Equal("SENT", Encoding.UTF8.GetString(serverBuffer, 0, serverLength)); 326await requestStream.WriteAsync(Encoding.UTF8.GetBytes("SENT")).AsTask().DefaultTimeout(); 379Assert.Equal("POST Response", Encoding.UTF8.GetString(buffer, 0, length)); 386await requestStream.WriteAsync(Encoding.UTF8.GetBytes(new string('!', 1024 * 1024 * 50))).AsTask().DefaultTimeout(); 544() => requestStream.WriteAsync(Encoding.UTF8.GetBytes("Hello world")).AsTask(), 616var hello = Encoding.UTF8.GetBytes("hello"); 618var world = Encoding.UTF8.GetBytes("world!"); 808var hello = Encoding.UTF8.GetBytes("hello");

TestServerTests.cs (1)

223stream.Write(Encoding.ASCII.GetBytes("Hello World"));

Microsoft.AspNetCore.Tests (1)

WebApplicationTests.cs (1)

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

89var originalData = Encoding.UTF8.GetBytes("Hello World"); 114var originalData = Encoding.UTF8.GetBytes(new string('a', 130)); 140var originalData = Encoding.UTF8.GetBytes(new string('a', 0x1FFFF)); 170var originalData = Encoding.UTF8.GetBytes("Hello World"); 220var originalData = Encoding.UTF8.GetBytes("Hello World"); 245var originalData = Encoding.UTF8.GetBytes(new string('a', 130)); 270var originalData = Encoding.UTF8.GetBytes(new string('a', 0x1FFFF)); 303var originalData = Encoding.UTF8.GetBytes("Hello World");

Microsoft.AspNetCore.WebUtilities (29)

BufferedReadStream.cs (1)

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

FormPipeReader.cs (13)

37private readonly Encoding _encoding; 44: this(pipeReader, Encoding.UTF8) 52/// <param name="encoding">The <see cref="Encoding"/>.</param> 53public FormPipeReader(PipeReader pipeReader, Encoding encoding) 56if (encoding is Encoding { CodePage: 65000 }) 64if (_encoding != Encoding.UTF8 && _encoding != Encoding.ASCII) 392else if (_encoding == Encoding.UTF8 || _encoding == Encoding.ASCII) 424if (_encoding == Encoding.UTF8 || _encoding == Encoding.ASCII) 436if (_encoding == Encoding.UTF8 || _encoding == Encoding.ASCII)

FormReader.cs (3)

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

HttpRequestStreamReader.cs (4)

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

HttpResponseStreamWriter.cs (5)

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

MultipartBoundary.cs (1)

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

MultipartSectionStreamExtensions.cs (2)

39var streamEncoding = sectionMediaType?.Encoding; 43streamEncoding = Encoding.UTF8;

Microsoft.AspNetCore.WebUtilities.Microbenchmarks (9)

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

src\Shared\Buffers.Testing\ReadOnlySequenceFactory.cs (1)

24return CreateWithContent(Encoding.ASCII.GetBytes(data));

Microsoft.AspNetCore.WebUtilities.Tests (129)

FileBufferingWriteStreamTests.cs (2)

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

FormPipeReaderTests.cs (43)

FormReaderTests.cs (1)

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

HttpRequestStreamReaderTest.cs (17)

HttpResponseStreamWriterTest.cs (41)

MultipartReaderTests.cs (21)

PagedByteBufferTest.cs (3)

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

src\Shared\Buffers.Testing\ReadOnlySequenceFactory.cs (1)

24return CreateWithContent(Encoding.ASCII.GetBytes(data));

Microsoft.Build (46)

BackEnd\Node\OutOfProcServerNode.cs (1)

459public override Encoding Encoding => _internalWriter.Encoding;

CommunicationsUtilities.cs (1)

183byte[] utf8 = Encoding.UTF8.GetBytes(input);

Construction\ProjectRootElement.cs (7)

77private static readonly Encoding s_defaultEncoding = Encoding.UTF8; 105private Encoding _encoding; 467public Encoding Encoding 483_encoding = Encoding.GetEncoding(declaration.Encoding); 1538public void Save(Encoding saveEncoding) 1607public void Save(string path, Encoding encoding)

Construction\Solution\SolutionFile.cs (2)

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

Definition\Project.cs (2)

1442public void Save(Encoding encoding) 1459public void Save(string path, Encoding encoding)

EncodingStringWriter.cs (3)

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

Evaluation\IntrinsicFunctions.cs (3)

400return Convert.ToBase64String(Encoding.UTF8.GetBytes(toEncode)); 410return Encoding.UTF8.GetString(Convert.FromBase64String(toDecode)); 467foreach (byte theByte in sha.ComputeHash(Encoding.UTF8.GetBytes(toHash)))

FileUtilities.cs (2)

1438internal static StreamWriter OpenWrite(string path, bool append, Encoding encoding = null) 1453internal static StreamReader OpenRead(string path, Encoding encoding = null, bool detectEncodingFromByteOrderMarks = true)

InterningBinaryReader.cs (3)

62: base(input, Encoding.UTF8) 71_decoder = Encoding.UTF8.GetDecoder(); 287_byteBuffer ??= new byte[Encoding.UTF8.GetMaxByteCount(MaxCharsBuffer)];

Logging\BinaryLogger\ProjectImportsCollector.cs (1)

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

Logging\FileLogger.cs (4)

46_encoding = Encoding.UTF8; 218_encoding = Encoding.GetEncoding(parameterValue); 265private Encoding _encoding = Encoding.Default;

Logging\TerminalLogger\Terminal.cs (3)

23private readonly Encoding _originalOutputEncoding; 76Console.OutputEncoding = Encoding.UTF8; 89_originalOutputEncoding = Encoding.UTF8;

ObjectModelRemoting\ConstructionObjectLinks\ProjectRootElementLink.cs (3)

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

ProjectWriter.cs (2)

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

TaskLoggingHelper.cs (1)

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

Utilities\NuGetFrameworkWrapper.cs (1)

196appDomainSetup.SetConfigurationBytes(Encoding.UTF8.GetBytes(configuration));

Xml\XmlReaderExtension.cs (7)

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

Microsoft.Build.CommandLine.UnitTests (2)

XMake_Tests.cs (2)

917var originalOutputEncoding = Console.OutputEncoding; 918var originalInputEncoding = Console.InputEncoding;

Microsoft.Build.Engine.OM.UnitTests (20)

Construction\ProjectRootElement_Tests.cs (11)

EncodingStringWriter.cs (3)

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

FileUtilities.cs (2)

ObjectModelRemoting\RemoteProjectsProviderMock\ConstructionLinkMocks\MockProjectRootElementLink.cs (4)

39public Encoding Encoding => this.ProjectXml.Encoding; // !! more complicated in reality when passing cross process. 139public void Save(Encoding saveEncoding) { this.ProjectXml.Save(saveEncoding); } 203public override Encoding Encoding => Proxy.Encoding; 318public override void Save(Encoding saveEncoding)

Microsoft.Build.Engine.UnitTests (2)

Construction\ProjectRootElement_Tests.cs (2)

32ObjectModelHelpers.CreateFileInTempProjectDirectory(Guid.NewGuid().ToString("N"), contents, Encoding.UTF8) : 52ObjectModelHelpers.CreateFileInTempProjectDirectory(Guid.NewGuid().ToString("N"), contents, Encoding.UTF8) :

Microsoft.Build.Framework (18)

EncodingUtilities.cs (17)

25internal static readonly Encoding Utf8WithoutBom = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false); 27private static Encoding s_currentOemEncoding; 39internal static Encoding CurrentSystemOemEncoding 51s_currentOemEncoding = Encoding.Default; 64s_currentOemEncoding = Encoding.GetEncoding(NativeMethods.GetOEMCP()); 91internal static bool SimilarToEncoding(this Encoding encoding1, Encoding encoding2) 116internal static bool IsUtf8Encoding(this Encoding encoding) 118return SimilarToEncoding(encoding, Encoding.UTF8); 128return StartsWithPreamble(stream, Encoding.UTF8.GetPreamble()); 195var systemEncoding = Encoding.GetEncoding(codePage, EncoderFallback.ExceptionFallback, 200var oemBytes = Encoding.Convert(unicodeEncoding, systemEncoding, unicodeBytes); 222internal static Encoding BatchFileEncoding(string contents, string encodingSpecification) 229var defaultEncoding = EncodingUtilities.CurrentSystemOemEncoding; 277Console.OutputEncoding = Encoding.UTF8; 279Console.InputEncoding = Encoding.UTF8;

Telemetry\ActivityExtensions.cs (1)

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

Microsoft.Build.Tasks.CodeAnalysis (10)

ManagedCompiler.cs (2)

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

src\Compilers\Core\CommandLine\BuildProtocol.cs (4)

src\Compilers\Core\CommandLine\CompilerServerLogger.cs (1)

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

src\Compilers\Core\CommandLine\ConsoleUtil.cs (2)

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

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

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

Microsoft.Build.Tasks.Core (36)

AddToWin32Manifest.cs (1)

171using (var xmlWriter = new XmlTextWriter(ManifestPath, Encoding.UTF8))

AssemblyDependency\AssemblyInformation.cs (1)

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

BootstrapperUtil\BootstrapperBuilder.cs (1)

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

BootstrapperUtil\ResourceUpdater.cs (1)

146byte[] strBytes = System.Text.Encoding.Unicode.GetBytes(str);

Exec.cs (7)

58private Encoding _standardErrorEncoding; 59private Encoding _standardOutputEncoding; 129protected override Encoding StandardOutputEncoding => _standardOutputEncoding; 134protected override Encoding StandardErrorEncoding => _standardErrorEncoding; 147_standardOutputEncoding = Encoding.GetEncoding(value); 168_standardErrorEncoding = Encoding.GetEncoding(value); 201var encoding = EncodingUtilities.BatchFileEncoding(Command + WorkingDirectory, UseUtf8Encoding);

FileIO\WriteLinesToFile.cs (3)

22private static readonly Encoding s_defaultEncoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true); 83Encoding encoding = s_defaultEncoding; 88encoding = System.Text.Encoding.GetEncoding(Encoding);

FileUtilities.cs (2)

GenerateResource.cs (2)

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

Hash.cs (2)

28private static readonly Encoding s_encoding = Encoding.UTF8;

InterningBinaryReader.cs (3)

62: base(input, Encoding.UTF8) 71_decoder = Encoding.UTF8.GetDecoder(); 287_byteBuffer ??= new byte[Encoding.UTF8.GetMaxByteCount(MaxCharsBuffer)];

ManifestUtil\ManifestFormatter.cs (1)

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

ManifestUtil\ManifestWriter.cs (1)

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

ManifestUtil\mansign2.cs (2)

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

ManifestUtil\Util.cs (1)

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

ManifestUtil\XmlUtil.cs (1)

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

ResourceHandling\MSBuildResXReader.cs (5)

251Encoding.RegisterProvider(CodePagesEncodingProvider.Instance); 256Encoding textFileEncoding = fileRefEncoding != null 257? Encoding.GetEncoding(fileRefEncoding) 258: Encoding.Default; 323using (var x = new MemoryStream(Encoding.UTF8.GetBytes(resxContent)))

StreamMappedString.cs (2)

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

Microsoft.Build.Tasks.UnitTests (7)

CreateCSharpManifestResourceName_Tests.cs (1)

88using StreamReader r = new StreamReader(m, System.Text.Encoding.ASCII, true); // HIGHCHAR: Test reads ANSI because that's the scenario.

DownloadFile_Tests.cs (1)

220return new MemoryStream(Encoding.Unicode.GetBytes(content)).CopyToAsync(stream);

Exec_Tests.cs (2)

1065public Encoding StdOutputEncoding 1073public Encoding StdErrorEncoding

ResourceHandling\MSBuildResXReader_Tests.cs (2)

164Encoding.RegisterProvider(CodePagesEncodingProvider.Instance); 169Encoding.GetEncoding("shift_jis"));

StreamMappedString_Tests.cs (1)

159Stream stream = StreamHelpers.StringToStream("\u00C3ngelo's Steak House", System.Text.Encoding.UTF32);

Microsoft.Build.UnitTests.Shared (5)

ObjectModelHelpers.cs (2)

626Encoding = Encoding.UTF8, 902public static string CreateFileInTempProjectDirectory(string fileRelativePath, [StringSyntax(StringSyntaxAttribute.Xml)] string fileContents, Encoding encoding = null)

StreamHelpers.cs (3)

24TextWriter w = new StreamWriter(m, System.Text.Encoding.UTF8); 45return StringToStream(value, System.Text.Encoding.UTF8); // We want this to be Default which is ANSI 55public static Stream StringToStream(string value, System.Text.Encoding encoding)

Microsoft.Build.Utilities.Core (9)

FileUtilities.cs (2)

TaskLoggingHelper.cs (1)

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

ToolTask.cs (6)

155private Encoding _encoding; 221protected virtual Encoding ResponseFileEncoding => Encoding.UTF8; 237protected virtual Encoding StandardOutputEncoding 261protected virtual Encoding StandardErrorEncoding 1432Encoding encoding;

Microsoft.Build.Utilities.UnitTests (2)

EncodingUtilities_Tests.cs (2)

22var defaultEncoding = EncodingUtilities.CurrentSystemOemEncoding; 58var alwaysEncoding = EncodingUtilities.BatchFileEncoding(content, EncodingUtilities.UseUtf8Always);

Microsoft.CodeAnalysis (104)

CommandLine\CommandLineArguments.cs (1)

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

CommandLine\CommandLineParser.cs (2)

1188internal static Encoding? TryParseEncodingName(string arg) 1196return Encoding.GetEncoding((int)codepage);

CommandLine\CommonCompiler.cs (5)

74private readonly Lazy<Encoding> _fallbackEncoding = new Lazy<Encoding>(EncodedStringText.CreateFallbackEncoding); 354internal Encoding? GetFallbackEncoding() 372using (var reader = new StreamReader(data, Encoding.UTF8)) 1755var bytes = Encoding.UTF8.GetBytes(key);

Compilation\Compilation.cs (1)

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

CryptographicHashProvider.cs (1)

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

CvtRes.cs (3)

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

DiaSymReader\Writer\SymUnmanagedWriterImpl.cs (3)

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

Emit\EmitOptions.cs (6)

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

EncodedStringText.cs (15)

20private static readonly Encoding s_utf8Encoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true); 22private static readonly Lazy<Encoding> s_fallbackEncoding = new(CreateFallbackEncoding); 30internal static Encoding CreateFallbackEncoding() 38Encoding.RegisterProvider(CodePagesEncodingProvider.Instance); 43return Encoding.GetEncoding(0) 44?? Encoding.GetEncoding(1252); 48return Encoding.GetEncoding(name: "Latin1"); 54/// from <see cref="SourceText.From(Stream, Encoding, SourceHashAlgorithm, bool)"/> in two ways: 73Encoding? defaultEncoding = null, 85Lazy<Encoding> getEncoding, 86Encoding? defaultEncoding = null, 129Encoding encoding, 230internal static SourceText Create(Stream stream, Lazy<Encoding> getEncoding, Encoding defaultEncoding, SourceHashAlgorithm checksumAlgorithm, bool canBeEmbedded) 233internal static SourceText Decode(Stream data, Encoding encoding, SourceHashAlgorithm checksumAlgorithm, bool throwIfBinaryDetected, bool canBeEmbedded)

InternalUtilities\EncodingExtensions.cs (1)

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

InternalUtilities\StringTable.cs (1)

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

MetadataReader\PEModule.cs (1)

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

PEWriter\MetadataWriter.cs (2)

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)

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

Syntax\SyntaxNode.cs (2)

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

Syntax\SyntaxTree.cs (1)

104public abstract Encoding? Encoding { get; }

Text\ChangedText.cs (1)

102public override Encoding? Encoding

Text\CompositeText.cs (5)

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

Text\LargeText.cs (6)

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

Text\LargeTextWriter.cs (3)

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

Text\SourceText.cs (24)

48private static readonly Encoding s_utf8EncodingWithNoBOM = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: false); 98/// If an encoding-less <see cref="SourceText"/> is written to a file a <see cref="Encoding.UTF8"/> shall be used as a default. 105public static SourceText From(string text, Encoding? encoding = null, SourceHashAlgorithm checksumAlgorithm = SourceHashAlgorithm.Sha1) 124/// If an encoding-less <see cref="SourceText"/> is written to a file a <see cref="Encoding.UTF8"/> shall be used as a default. 134Encoding? encoding = null, 154public static SourceText From(Stream stream, Encoding? encoding, SourceHashAlgorithm checksumAlgorithm, bool throwIfBinaryDetected) 163/// <see cref="Encoding.UTF8"/> if not specified. 182Encoding? encoding = null, 225public static SourceText From(byte[] buffer, int length, Encoding? encoding, SourceHashAlgorithm checksumAlgorithm, bool throwIfBinaryDetected) 235/// <see cref="Encoding.UTF8"/> if not specified. 252Encoding? encoding = null, 290private static string Decode(Stream stream, Encoding encoding, out Encoding actualEncoding) 333private static string Decode(byte[] buffer, int length, Encoding encoding, out Encoding actualEncoding) 392/// If an encoding-less <see cref="SourceText"/> is written to a file a <see cref="Encoding.UTF8"/> shall be used as a default. 394public abstract Encoding? Encoding { get; } 424/// If this text was constructed via <see cref="From(byte[], int, Encoding, SourceHashAlgorithm, bool, bool)"/> or 425/// <see cref="From(Stream, Encoding, SourceHashAlgorithm, bool, bool)"/>, then the canBeEmbedded arg must have 1218internal static Encoding? TryReadByteOrderMark(byte[] source, int length, out int preambleLength) 1231return Encoding.BigEndianUnicode; 1240return Encoding.Unicode; 1249return Encoding.UTF8; 1289internal static int GetMaxCharCountOrThrowIfHuge(Encoding encoding, Stream stream)

Text\SourceTextStream.cs (2)

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

Text\SourceTextWriter.cs (1)

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

Text\StringBuilderText.cs (3)

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

Text\StringText.cs (3)

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

Text\StringTextWriter.cs (3)

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

Text\SubText.cs (1)

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

Microsoft.CodeAnalysis.Analyzers (3)

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

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

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)

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

Microsoft.CodeAnalysis.AnalyzerUtilities (3)

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

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

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)

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

Microsoft.CodeAnalysis.BannedApiAnalyzers (3)

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

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

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)

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

Microsoft.CodeAnalysis.CodeStyle (49)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

CommandLine\CSharpCommandLineParser.cs (2)

108Encoding? codepage = null; 365var encoding = TryParseEncodingName(value);

Symbols\FileIdentifier.cs (1)

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

Syntax\CSharpSyntaxTree.cs (8)

314public static SyntaxTree Create(CSharpSyntaxNode root, CSharpParseOptions? options = null, string? path = "", Encoding? encoding = null) 334Encoding? encoding, 361Encoding? encoding, 393/// <para>NOTE: Do not use this method elsewhere, instead use <see cref="Create(CSharpSyntaxNode, CSharpParseOptions, string, Encoding)"/> method for creating a syntax tree.</para> 434Encoding? encoding = null, 455Encoding? encoding, 925Encoding? encoding, 937Encoding? encoding,

Syntax\CSharpSyntaxTree.Dummy.cs (2)

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

Syntax\CSharpSyntaxTree.LazySyntaxTree.cs (1)

55public override Encoding? Encoding

Syntax\CSharpSyntaxTree.ParsedSyntaxTree.cs (3)

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

Syntax\SyntaxFactory.cs (6)

1547public static SyntaxTree SyntaxTree(SyntaxNode root, ParseOptions? options = null, string path = "", Encoding? encoding = null) 1554/// <inheritdoc cref="CSharpSyntaxTree.ParseText(string, CSharpParseOptions?, string, Encoding?, CancellationToken)"/> 1559Encoding? encoding = null, 1913return SourceText.From(text, Encoding.UTF8).GetSubText(offset); 2786Encoding? encoding, 2813Encoding? encoding,

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

CommandLineTests.cs (10)

411Assert.Equal("星野八郎太", File.ReadAllText(Path.Combine(dir.Path, "output.txt"), Encoding.GetEncoding(932))); 431Assert.Equal("星野八郎太", File.ReadAllText(Path.Combine(dir.Path, "output.txt"), Encoding.GetEncoding(932))); 2307byte[] slContent = Encoding.UTF8.GetBytes(@"{ ""documents"" : {} }"); 2525var sourceStr = Encoding.UTF8.GetString(sourceBlob.Array, sourceBlob.Offset, sourceBlob.Count); 2537private static void ValidateWrittenSources(Dictionary<string, Dictionary<string, string>> expectedFilesMap, Encoding encoding = null) 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)); 14041context.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 (42)

Debugging\ProximityExpressionsGetterTests.cs (1)

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

PdbSourceDocument\AbstractPdbSourceDocumentTests.cs (6)

196Encoding? encoding = null) 198var sourceText = SourceText.From(source, encoding: encoding ?? Encoding.UTF8); 211Encoding? fallbackEncoding = null) 248protected static void CompileTestSource(string path, SourceText source, Project project, Location pdbLocation, Location sourceLocation, bool buildReferenceAssembly, bool windowsPdb, Encoding? fallbackEncoding = null) 258protected static void CompileTestSource(string dllFilePath, string sourceCodePath, string? pdbFilePath, string assemblyName, SourceText source, Project project, Location pdbLocation, Location sourceLocation, bool buildReferenceAssembly, bool windowsPdb, Encoding? fallbackEncoding = null) 263protected static void CompileTestSource(string dllFilePath, string[] sourceCodePaths, string? pdbFilePath, string assemblyName, SourceText[] sources, Project project, Location pdbLocation, Location sourceLocation, bool buildReferenceAssembly, bool windowsPdb, Encoding? fallbackEncoding = null)

PdbSourceDocument\ImplementationAssemblyLookupServiceTests.cs (17)

PdbSourceDocument\PdbSourceDocumentLoaderServiceTests.cs (2)

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

PdbSourceDocument\PdbSourceDocumentTests.cs (16)

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

Emit\CompilationEmitTests.cs (6)

289Encoding.UTF8.GetString(xmlDocBytes)); 335Encoding.UTF8.GetString(xmlDocBytes)); 389Encoding.UTF8.GetString(xmlDocBytes)); 445Encoding.UTF8.GetString(xmlDocBytes)); 498Encoding.UTF8.GetString(xmlDocBytes)); 547Encoding.UTF8.GetString(xmlDocBytes));

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

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

109", filename: "a.cs", options: parseOptions, encoding: Encoding.UTF8); 119}", filename: "c.cs", options: parseOptions, encoding: Encoding.Unicode); 169", filename: "a.cs", options: parseOptions, encoding: Encoding.UTF8); 179}", filename: "a.cs", options: parseOptions, encoding: Encoding.Unicode); 233", filename: "a.cs", options: parseOptions, encoding: Encoding.UTF8); 243}", filename: "c.cs", options: parseOptions, encoding: Encoding.GetEncoding(932)); // SJIS encoding

PDB\PDBSourceLinkTests.cs (2)

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

PDB\PDBTests.cs (5)

48var tree4 = SyntaxFactory.ParseSyntaxTree("class D { }", encoding: Encoding.UTF8, path: "Baz.cs"); 65var tree1 = SyntaxFactory.ParseSyntaxTree("class A { public void F() { } }", encoding: Encoding.Unicode, path: "Foo.cs"); 76var hash1 = CryptographicHashProvider.ComputeSha1(Encoding.Unicode.GetBytesWithPreamble(tree1.ToString())).ToArray(); 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 (23)

Attributes\AttributeTests_CallerInfoAttributes.cs (15)

Attributes\AttributeTests_MarshalAs.cs (7)

757var arrayAqn = Encoding.ASCII.GetBytes("System.Int32*[][], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"); 758var openGenericAqn = Encoding.ASCII.GetBytes("System.Nullable`1, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"); 798var nestedAqn = Encoding.ASCII.GetBytes("C`1+D`1+E[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[System.Boolean, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]"); 830var e = Encoding.ASCII; 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.Features (3)

EmbeddedLanguages\CSharpTestEmbeddedLanguageClassifier.cs (3)

111var encoding = semanticModel.SyntaxTree.Encoding; 274public override Encoding? Encoding { get; } 276public VirtualCharSequenceSourceText(VirtualCharSequence virtualChars, Encoding? encoding)

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

EditAndContinue\CSharpEditAndContinueAnalyzerTests.cs (1)

45AddDocument("test.cs", SourceText.From(source, Encoding.UTF8), filePath: Path.Combine(TempRoot.Root, "test.cs")).Project.Solution;

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

ScriptTests.cs (12)

52var script = CSharpScript.Create(new MemoryStream(Encoding.UTF8.GetBytes("1 + 2")), ScriptOptions); 148var script = CSharpScript.Create(new MemoryStream(Encoding.UTF8.GetBytes("1 + 2")), ScriptOptions); 865var opts = ScriptOptions.WithEmitDebugInformation(true).WithFilePath("debug.csx").WithFileEncoding(Encoding.UTF8); 879var opts = ScriptOptions.WithEmitDebugInformation(false).WithFilePath("debug.csx").WithFileEncoding(Encoding.UTF8); 888return VerifyStackTraceAsync(() => CSharpScript.Create(new MemoryStream(Encoding.UTF8.GetBytes("throw new System.Exception();")), opts), line: 1, column: 1, filename: "debug.csx"); 895return VerifyStackTraceAsync(() => CSharpScript.Create(new MemoryStream(Encoding.UTF8.GetBytes("throw new System.Exception();")), opts)); 910var opts = ScriptOptions.WithEmitDebugInformation(true).WithFileEncoding(Encoding.UTF8); 924var opts = ScriptOptions.WithEmitDebugInformation(false).WithFileEncoding(Encoding.UTF8); 933return VerifyStackTraceAsync(() => CSharpScript.Create(new MemoryStream(Encoding.UTF8.GetBytes("throw new System.Exception();")), opts), line: 1, column: 1, filename: ""); 940return VerifyStackTraceAsync(() => CSharpScript.Create(new MemoryStream(Encoding.UTF8.GetBytes("throw new System.Exception();")), opts)); 1115System.Text.Encoding.ASCII.GetBytes(text, 0, text.Length, bytes, padding); 1128System.Text.Encoding.ASCII,

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

Semantics\TopLevelStatementsTests.cs (2)

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

SourceGeneration\AdditionalSourcesCollectionTests.cs (20)

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

Compilation\CompilationAPITests.cs (2)

2264var appConfig = new MemoryStream(Encoding.UTF8.GetBytes( 2324var appConfig = new MemoryStream(Encoding.UTF8.GetBytes(

DeclarationTests.cs (1)

983public override Encoding Encoding

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

Symbols\Source\FileModifierTests.cs (14)

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

Syntax\Mocks\MockCSharpSyntaxTree.cs (2)

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

Syntax\SyntaxTreeTests.cs (7)

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"), 259var oldText = SourceText.From("class B {}", Encoding.Unicode, SourceHashAlgorithms.Default); 269Assert.Same(Encoding.Unicode, newText.Encoding); 301var oldText = SourceText.From("class B {}", Encoding.Unicode, SourceHashAlgorithms.Default); 310Assert.Same(Encoding.Unicode, newText.Encoding);

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

CSharpTestBase.cs (2)

1195public static SyntaxTree Parse(string text, string filename = "", CSharpParseOptions? options = null, Encoding? encoding = null, SourceHashAlgorithm checksumAlgorithm = SourceHashAlgorithm.Sha1) 1981string text = Encoding.UTF8.GetString(stream.ToArray());

CSharpTestSource.cs (2)

38Encoding encoding = null, 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.CSharp.Workspaces (3)

Workspace\LanguageServices\CSharpSyntaxTreeFactoryService.cs (1)

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

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

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

Microsoft.CodeAnalysis.Debugging.Package (1)

CustomDebugInfoReader.cs (1)

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

Microsoft.CodeAnalysis.EditorFeatures (6)

Workspaces\EditorTextFactoryService.cs (6)

30private static readonly Encoding s_throwingUtf8Encoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true); 32public SourceText CreateText(Stream stream, Encoding? defaultEncoding, SourceHashAlgorithm checksumAlgorithm, CancellationToken cancellationToken) 50defaultEncoding = Encoding.Default; 65public SourceText CreateText(TextReader reader, Encoding? encoding, SourceHashAlgorithm checksumAlgorithm, CancellationToken cancellationToken) 77private SourceText CreateTextInternal(Stream stream, Encoding encoding, SourceHashAlgorithm checksumAlgorithm, CancellationToken cancellationToken) 85return buffer.CurrentSnapshot.AsRoslynText(_textBufferCloneService, reader.CurrentEncoding ?? Encoding.UTF8, checksumAlgorithm);

Microsoft.CodeAnalysis.EditorFeatures.Text (9)

Extensions.cs (4)

45internal static SourceText AsRoslynText(this ITextSnapshot textSnapshot, ITextBufferCloneService textBufferCloneServiceOpt, Encoding? encoding, SourceHashAlgorithm checksumAlgorithm) 96/// Note that this will return <see cref="Encoding.UTF8"/> if the <see cref="ITextBuffer"/> 101internal static Encoding GetEncodingOrUTF8(this ITextBuffer textBuffer) 104: Encoding.UTF8;

Extensions.SnapshotSourceText.cs (5)

34private readonly Encoding? _encoding; 37private SnapshotSourceText(ITextBufferCloneService? textBufferCloneService, ITextSnapshot editorSnapshot, Encoding? encoding, SourceHashAlgorithm checksumAlgorithm, TextBufferContainer container) 48public SnapshotSourceText(ITextBufferCloneService? textBufferCloneService, ITextImage textImage, Encoding? encoding, SourceHashAlgorithm checksumAlgorithm, TextBufferContainer? container) 105public override Encoding? Encoding 266public ClosedSnapshotSourceText(ITextBufferCloneService? textBufferCloneService, ITextImage textImage, Encoding? encoding, SourceHashAlgorithm checksumAlgorithm)

Microsoft.CodeAnalysis.EditorFeatures.UnitTests (14)

EditAndContinue\EditAndContinueLanguageServiceTests.cs (4)

240var sourceFile = dir.CreateFile("test.cs").WriteAllText(source1, Encoding.UTF8); 255loader: new WorkspaceFileTextLoader(workspace.Services.SolutionServices, sourceFile.Path, Encoding.UTF8), 267File.WriteAllText(sourceFile.Path, source2, Encoding.UTF8); 274Text = SourceText.From(source3, Encoding.UTF8, SourceHashAlgorithm.Sha1)

Workspaces\TextFactoryTests.cs (10)

33expectedEncoding: Encoding.Default); 58defaultEncoding: Encoding.GetEncoding(1254), 59expectedEncoding: Encoding.GetEncoding(1254)); 71.. Encoding.UTF8.GetPreamble(), 74defaultEncoding: Encoding.GetEncoding(1254), 75expectedEncoding: Encoding.UTF8); 105var text = SourceText.From("Hello, World!", Encoding.ASCII); 115Assert.Equal(text2.Encoding, Encoding.ASCII); 118private static void TestCreateTextInferredEncoding(ITextFactoryService textFactoryService, byte[] bytes, Encoding? defaultEncoding, Encoding expectedEncoding)

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

EditAndContinue\CommittedSolution.cs (1)

479Encoding? encoding,

EditAndContinue\TraceLog.cs (1)

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

MetadataAsSource\MetadataAsSourceGeneratedFileInfo.cs (2)

48public static Encoding Encoding => Encoding.UTF8;

PdbSourceDocument\IPdbSourceDocumentLoaderService.cs (1)

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

PdbSourceDocument\PdbSourceDocumentLoaderService.cs (5)

37public async Task<SourceFileInfo?> LoadSourceDocumentAsync(string tempFilePath, SourceDocument sourceDocument, Encoding encoding, TelemetryMessage telemetry, bool useExtendedTimeout, CancellationToken cancellationToken) 46private SourceFileInfo? TryGetEmbeddedSourceFile(string tempFilePath, SourceDocument sourceDocument, Encoding encoding, TelemetryMessage telemetry) 124private async Task<SourceFileInfo?> TryGetSourceLinkFileAsync(SourceDocument sourceDocument, Encoding encoding, TelemetryMessage telemetry, bool useExtendedTimeout, CancellationToken cancellationToken) 168private SourceFileInfo? TryGetOriginalFile(SourceDocument sourceDocument, Encoding encoding, TelemetryMessage telemetry) 189private static SourceFileInfo? LoadSourceFile(string filePath, SourceDocument sourceDocument, Encoding encoding, string sourceDescription, bool ignoreChecksum, bool fromRemoteLocation)

PdbSourceDocument\PdbSourceDocumentMetadataAsSourceFileProvider.cs (7)

209Encoding? defaultEncoding = null; 212defaultEncoding = Encoding.GetEncoding(encodingString); 216defaultEncoding = Encoding.GetEncoding(fallbackEncodingString); 257var encoding = defaultEncoding ?? Encoding.UTF8; 338SourceFileInfo?[] sourceFileInfos, Encoding encoding, ProjectId projectId, Workspace sourceWorkspace, Project sourceProject) 490internal record struct SourceDocumentInfo(DocumentId DocumentId, Encoding Encoding, SourceHashAlgorithm ChecksumAlgorithm, ProjectId SourceProjectId, Workspace SourceWorkspace, DocumentInfo DocumentInfo);

SemanticSearch\SemanticSearchUtilities.cs (1)

69=> SourceText.From(query, Encoding.UTF8, SourceHashAlgorithm.Sha256);

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

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

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

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

154=> projectDirectory?.CreateFile(fileName).WriteAllText(content, Encoding.UTF8).Path ?? Path.Combine(TempRoot.Root, fileName); 262Encoding? encoding = null, 281Encoding? encoding = null, 297Encoding? encoding = null, 306encoding ??= Encoding.UTF8; 375=> SourceText.From(source, Encoding.UTF8, SourceHashAlgorithms.Default); 380return SourceText.From(stream, Encoding.UTF8, SourceHashAlgorithms.Default);

EditAndContinue\Extensions.cs (3)

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

Microsoft.CodeAnalysis.Features.UnitTests (52)

EditAndContinue\ActiveStatementsMapTests.cs (3)

118.AddDocument("doc", SourceText.From(source, Encoding.UTF8), filePath: "a.cs").Project.Solution; 173.AddDocument("doc", SourceText.From(source, Encoding.UTF8), filePath: "a.cs").Project.Solution; 224.AddDocument("doc", SourceText.From(source, Encoding.UTF8), filePath: "a.cs").Project.Solution;

EditAndContinue\EditAndContinueWorkspaceServiceTests.cs (41)

EditAndContinue\EditSessionActiveStatementsTests.cs (1)

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

EditAndContinue\EmitSolutionUpdateResultsTests.cs (1)

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

EditAndContinue\RemoteEditAndContinueServiceTests.cs (1)

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

EditAndContinue\UnitTestingHotReloadServiceTests.cs (2)

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

EditAndContinue\WatchHotReloadServiceTests.cs (3)

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

Microsoft.CodeAnalysis.InteractiveHost (4)

Interactive\Core\InteractiveHost.cs (2)

36internal static readonly Encoding OutputEncoding = Encoding.Unicode;

Interactive\Core\InteractiveHost.RemoteService.cs (2)

111return Encoding.Unicode.GetChars(Encoding.ASCII.GetBytes(ascii));

Microsoft.CodeAnalysis.LanguageServer (1)

HostWorkspace\ProjectTelemetry\VsReferenceHashingAlgorithm.cs (1)

98return Encoding.Unicode.GetBytes(cleartext);

Microsoft.CodeAnalysis.LanguageServer.Protocol (2)

Features\Diagnostics\DiagnosticDataExtensions.cs (1)

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

Handler\DocumentChanges\DidOpenHandler.cs (1)

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

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

Workspaces\LspWorkspaceManagerTests.cs (3)

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

Microsoft.CodeAnalysis.PublicApiAnalyzers (3)

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

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

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)

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

Microsoft.CodeAnalysis.Rebuild (6)

CompilationOptionsReader.cs (5)

109public Encoding GetEncoding() 118var encoding = encodingString is null 119? Encoding.UTF8 120: Encoding.GetEncoding(encodingString); 178var encoding = GetEncoding();

Records.cs (1)

23Encoding SourceTextEncoding);

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.Remote.ServiceHub (1)

Services\BrokeredServiceBase.cs (1)

46Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);

Microsoft.CodeAnalysis.Remote.Workspaces (12)

Serialization\MessagePackFormatters.cs (12)

132/// Supports (de)serialization of <see cref="Encoding"/> that do not customize <see cref="Encoding.EncoderFallback"/> or <see cref="Encoding.DecoderFallback"/>. 133/// The fallback will be discarded if the <see cref="Encoding"/> has any. 136/// Only supports (de)serializing values that are statically typed to <see cref="Encoding"/>. 137/// This is important as we can't assume anything about arbitrary subtypes of <see cref="Encoding"/> 138/// and can only return general <see cref="Encoding"/> from the deserializer. 140internal sealed class EncodingFormatter : IMessagePackFormatter<Encoding?> 144public Encoding? Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) 162return Encoding.GetEncoding(codePage); 171return Encoding.GetEncoding(name); 179public void Serialize(ref MessagePackWriter writer, Encoding? value, MessagePackSerializerOptions options)

Microsoft.CodeAnalysis.ResxSourceGenerator (7)

AbstractResxGenerator.cs (4)

208var errorText = SourceText.From(text, Encoding.UTF8, SourceHashAlgorithm.Sha256); 322OutputText = SourceText.From("", Encoding.UTF8); 346OutputText = SourceText.From(result, Encoding.UTF8, SourceHashAlgorithm.Sha256); 704OutputText = SourceText.From(result, Encoding.UTF8, SourceHashAlgorithm.Sha256);

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

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

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)

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

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

ScriptOptions.cs (3)

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

Microsoft.CodeAnalysis.Scripting.TestUtilities (4)

TestConsoleIO.cs (4)

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

Microsoft.CodeAnalysis.Scripting.UnitTests (4)

ScriptOptionsTests.cs (4)

185var options = ScriptOptions.Default.WithFileEncoding(Encoding.ASCII); 186Assert.Equal(Encoding.ASCII, options.FileEncoding); 192var options = ScriptOptions.Default.WithFileEncoding(Encoding.ASCII); 193Assert.Same(options, options.WithFileEncoding(Encoding.ASCII));

Microsoft.CodeAnalysis.Test.Utilities (35)

Assert\ConditionalFactAttribute.cs (2)

207public override bool ShouldSkip => Encoding.GetEncoding(0)?.CodePage != 932; 220return Encoding.GetEncoding(0)?.CodePage != 1252;

CommonTestBase.cs (2)

426Encoding? encoding = null, 437Encoding? encoding = null,

EncodingTestHelpers.cs (4)

17public static IEnumerable<Encoding?> GetEncodings() 20Encoding.RegisterProvider(CodePagesEncodingProvider.Instance); 44public static void AssertEncodingsEqual(Encoding? expected, Encoding? actual)

FX\EncodingUtilities.cs (1)

13public static byte[] GetBytesWithPreamble(this Encoding encoding, string text)

Metadata\MetadataReaderUtils.cs (1)

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

Mocks\TestAdditionalText.cs (1)

22public TestAdditionalText(string text = "", Encoding? encoding = null, string path = "dummy", SourceHashAlgorithm checksumAlgorithm = SourceHashAlgorithm.Sha1)

Mocks\TestSourceReferenceResolver.cs (1)

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

PDB\DeterministicBuildCompilationTestHelpers.cs (5)

39defaultSourceFileEncoding: Encoding.UTF32); 42yield return emitOptions.WithDefaultSourceFileEncoding(Encoding.ASCII); 43yield return emitOptions.WithDefaultSourceFileEncoding(null).WithFallbackSourceFileEncoding(Encoding.Unicode); 44yield return emitOptions.WithFallbackSourceFileEncoding(Encoding.Unicode).WithDefaultSourceFileEncoding(Encoding.ASCII);

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

27public override Encoding Encoding => Encoding.UTF8;

TempFiles\TempFile.cs (3)

70public TempFile WriteAllText(string content, Encoding encoding) 82public async Task<TempFile> WriteAllTextAsync(string content, Encoding encoding) 94return WriteAllTextAsync(content, Encoding.UTF8);

TestableFile.cs (1)

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

Win32Res.cs (7)

47private static string GetManifestString(IntPtr ptr, int offset, int length, Encoding encoding) 59Encoding encoding; 63encoding = Encoding.Unicode; 69encoding = Encoding.BigEndianUnicode; 75encoding = Encoding.UTF8; 81encoding = Encoding.ASCII; 171var reader = new BinaryReader(memoryStream, Encoding.Unicode);

Microsoft.CodeAnalysis.TestAnalyzerReference (3)

HelloWorldGenerator.cs (3)

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

Microsoft.CodeAnalysis.UnitTests (104)

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

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)); 158var bytes = Encoding.Unicode.GetBytes(LargeSource); 172var bytes = Encoding.Unicode.GetBytes(LargeSource); 187var source = SourceText.From(LargeSource, Encoding.Unicode, SourceHashAlgorithms.Default); 193AssertEx.Equal(BitConverter.GetBytes(Encoding.Unicode.GetPreamble().Length + LargeSource.Length * sizeof(char)), text.Blob.Take(4)); 194AssertEx.Equal(Encoding.Unicode.GetPreamble().Concat(Encoding.Unicode.GetBytes(LargeSource)), Decompress(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); 230byte[] bytes = Encoding.ASCII.GetBytes(LargeSource); 236SourceText.From(new MemoryStream(bytes), Encoding.ASCII, SourceHashAlgorithm.Sha1, canBeEmbedded: true) : 237SourceText.From(bytes, bytes.Length, Encoding.ASCII, SourceHashAlgorithm.Sha1, canBeEmbedded: true);

StringTableTests.cs (1)

89fixed (byte* ptr = Encoding.ASCII.GetBytes(ascii))

Text\LargeTextTests.cs (7)

18private static SourceText CreateSourceText(string s, Encoding encoding = null) 22using (StreamWriter sw = new StreamWriter(stream, encoding ?? Encoding.UTF8, bufferSize: 1024, leaveOpen: true)) 31private static SourceText CreateSourceText(Stream stream, Encoding encoding = null) 33return LargeText.Decode(stream, encoding ?? Encoding.UTF8, SourceHashAlgorithm.Sha1, throwIfBinaryDetected: true, canBeEmbedded: false); 36private static SourceText CreateSourceText(TextReader reader, int length, Encoding encoding = null) 38return LargeText.Decode(reader, length, encoding ?? Encoding.UTF8, SourceHashAlgorithm.Sha1); 115using (StreamWriter sw = new StreamWriter(stream, Encoding.UTF8, bufferSize: 1024, leaveOpen: true))

Text\SourceTextStreamTests.cs (2)

17private static readonly Encoding s_utf8NoBom = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false); 49var encoding = s_utf8NoBom;

Text\SourceTextTests.cs (22)

22private static readonly Encoding s_utf8 = Encoding.UTF8; 23private static readonly Encoding s_unicode = Encoding.Unicode; 201private static SourceText FromLargeTextWriter(string source, Encoding encoding, SourceHashAlgorithm checksumAlgorithm) 251var encodings = new[] { null, Encoding.ASCII, new UTF8Encoding(encoderShouldEmitUTF8Identifier: true), new UTF8Encoding(encoderShouldEmitUTF8Identifier: false) }; 258foreach (var encoding in encodings) 282var encodings = new[] { null, Encoding.ASCII, new UTF8Encoding(encoderShouldEmitUTF8Identifier: true), new UTF8Encoding(encoderShouldEmitUTF8Identifier: false) }; 284foreach (var encoding1 in encodings) 288foreach (var encoding2 in encodings) 296if (encoding1 == Encoding.ASCII && encoding2 == Encoding.ASCII) 305var sourceText1 = new StringText("；", Encoding.ASCII); // chinese semicolon 306var sourceText2 = new StringText("?", Encoding.ASCII); // what a non-ascii char will map to. 332var encoding = Encoding.UTF8; 384private static void TestTryReadByteOrderMark(Encoding expectedEncoding, int expectedPreambleLength, byte[] data) 389private static void TestTryReadByteOrderMark(Encoding expectedEncoding, int expectedPreambleLength, byte[] data, int validLength) 392Encoding actualEncoding = SourceText.TryReadByteOrderMark(data, validLength, out actualPreambleLength); 412TestTryReadByteOrderMark(expectedEncoding: Encoding.UTF8, expectedPreambleLength: 3, data: new byte[] { 0xef, 0xBB, 0xBF }); 415TestTryReadByteOrderMark(expectedEncoding: Encoding.Unicode, expectedPreambleLength: 2, data: new byte[] { 0xff, 0xfe }); 418TestTryReadByteOrderMark(expectedEncoding: Encoding.BigEndianUnicode, expectedPreambleLength: 2, data: new byte[] { 0xfe, 0xff });

Text\StringTextDecodingTests.cs (27)

Text\StringTextTest.cs (11)

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); 234var source = SourceText.From(new MemoryStream(bytes), Encoding.ASCII); 249var source = SourceText.From(new MemoryStream(bytes), Encoding.ASCII); 259var bytes = Encoding.UTF8.GetBytes("\u1234"); 276var source = SourceText.From(stream, Encoding.ASCII);

Text\StringTextTest_BigEndianUnicode.cs (1)

19byte[] buffer = GetBytes(Encoding.BigEndianUnicode, source);

Text\StringTextTest_Unicode.cs (1)

19byte[] buffer = GetBytes(Encoding.Unicode, source);

Text\StringTextTests_Default.cs (4)

18private Encoding _currentEncoding; 20protected byte[] GetBytes(Encoding encoding, string source) 28byte[] buffer = GetBytes(Encoding.Default, source); 146var originalText = Encoding.Default.GetString(new byte[] { 0xAB, 0xCD, 0xEF });

Text\TextChangeTests.cs (5)

189var text = SourceText.From("Hello World", Encoding.Unicode, SourceHashAlgorithms.Default); 198Assert.Same(Encoding.Unicode, subText.Encoding); 231var text = SourceText.From(new string('.', 2048), Encoding.Unicode, SourceHashAlgorithms.Default); // start bigger than GetText() copy buffer 241Assert.Same(Encoding.Unicode, newText.Encoding); 590return new LargeText(ImmutableArray.Create(chunks), Encoding.UTF8, default(ImmutableArray<byte>), SourceHashAlgorithms.Default, default(ImmutableArray<byte>));

Microsoft.CodeAnalysis.VisualBasic (19)

CommandLine\VisualBasicCommandLineParser.vb (1)

125Dim codepage As Encoding = Nothing

Symbols\EmbeddedSymbols\EmbeddedSymbolManager.vb (1)

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

Symbols\Source\SynthesizedMyGroupCollectionPropertyAccessorSymbol.vb (1)

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

Syntax\SyntaxNodeFactories.vb (4)

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

Syntax\VisualBasicSyntaxTree.DummySyntaxTree.vb (2)

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

Syntax\VisualBasicSyntaxTree.LazySyntaxTree.vb (1)

60Public Overrides ReadOnly Property Encoding As Encoding

Syntax\VisualBasicSyntaxTree.ParsedSyntaxTree.vb (3)

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

Syntax\VisualBasicSyntaxTree.vb (6)

165Optional encoding As Encoding = Nothing, 185encoding As Encoding, 240Optional encoding As Encoding = Nothing, 250Optional encoding As Encoding = Nothing, 616encoding As Encoding, 637encoding As Encoding) As SyntaxTree

Microsoft.CodeAnalysis.VisualBasic.CommandLine.UnitTests (4)

CommandLineTests.vb (4)

3440Dim sourceStr = Encoding.UTF8.GetString(sourceBlob.Array, sourceBlob.Offset, sourceBlob.Count) 9647backingStream:=New MemoryStream(Encoding.UTF8.GetBytes(" 10934Private Shared Sub ValidateWrittenSources(ByVal expectedFilesMap As Dictionary(Of String, Dictionary(Of String, String)), ByVal Optional encoding As Encoding = Nothing) 10941Dim content = File.ReadAllText(fileName, If(encoding, Encoding.UTF8))

Microsoft.CodeAnalysis.VisualBasic.Emit.UnitTests (23)

Attributes\AttributeTests_MarshalAs.vb (6)

605Dim aqn = Encoding.ASCII.GetBytes("System.Int32[][], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089") 606Dim openGenericAqn = Encoding.ASCII.GetBytes("System.Nullable`1, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089") 652Dim nestedAqn = Encoding.ASCII.GetBytes("C`1+D`1+E[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[System.Boolean, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]") 685Dim e = Encoding.ASCII 891{"CustomMarshaler6", New Byte() {&H2C, &H0, &H0, &H60}.Append(Encoding.UTF8.GetBytes("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" & ChrW(0)))}, 893{"CustomMarshaler8", New Byte() {&H2C, &H0, &H0, &H59}.Append(Encoding.UTF8.GetBytes("System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" & ChrW(0)))},

Emit\CompilationEmitTests.vb (7)

345Encoding.UTF8.GetString(xmlDocBytes)) 391Encoding.UTF8.GetString(xmlDocBytes)) 440Encoding.UTF8.GetString(xmlDocBytes)) 490Encoding.UTF8.GetString(xmlDocBytes)) 539Encoding.UTF8.GetString(xmlDocBytes)) 588Encoding.UTF8.GetString(xmlDocBytes)) 3578Dim hexFileContent = PermissionSetAttributeWithFileReference.ConvertToHex(New MemoryStream(Encoding.UTF8.GetBytes(text)))

PDB\PDBTests.vb (3)

28Dim tree4 = SyntaxFactory.ParseSyntaxTree("Class D : End Class", path:="Baz.vb", encoding:=Encoding.UTF8) 42Dim tree1 = SyntaxFactory.ParseSyntaxTree("Class A" & vbCrLf & "Sub F() : End Sub : End Class", path:="Goo.vb", encoding:=Encoding.Unicode) 53Dim hash1 = CryptographicHashProvider.ComputeSha1(Encoding.Unicode.GetBytesWithPreamble(tree1.ToString())).ToArray()

PDB\PortablePdbTests.vb (2)

190Dim sourceLinkBlob = Encoding.UTF8.GetBytes(" 226Dim sourceLinkBlob = Encoding.UTF8.GetBytes("

PDB\TypeDefinitionDocumentTests.vb (1)

345Dim trees = sources.Select(Function(s, i) SyntaxFactory.ParseSyntaxTree(s, path:=$"{i + 1}.vb", encoding:=Encoding.UTF8)).ToArray()

PDB\VisualBasicDeterministicBuildCompilationTests.vb (4)

77End Class", fileName:="one.vb", options:=compilationOptions.ParseOptions, encoding:=Encoding.UTF8) 120End Class", fileName:="one.vb", options:=compilationOptions.ParseOptions, encoding:=Encoding.UTF8) 128End Class", fileName:="three.vb", options:=compilationOptions.ParseOptions, encoding:=Encoding.GetEncoding(932)) ' SJIS encoding 177Yield emitOptions.WithDefaultSourceFileEncoding(Encoding.UTF8)

Microsoft.CodeAnalysis.VisualBasic.Features.UnitTests (1)

EditAndContinue\VisualBasicEditAndContinueAnalyzerTests.vb (1)

30AddDocument("test.vb", SourceText.From(source, Encoding.UTF8), filePath:=Path.Combine(TempRoot.Root, "test.vb")).Project.Solution

Microsoft.CodeAnalysis.VisualBasic.Semantic.UnitTests (9)

Semantics\OptionalArgumentTests.vb (9)

Microsoft.CodeAnalysis.VisualBasic.Syntax.UnitTests (6)

IncrementalParser\IncrementalParser.vb (1)

1717Dim oldTree2 = VisualBasicSyntaxTree.Create(DirectCast(oldRoot2, VisualBasicSyntaxNode), DirectCast(tempTree2.Options, VisualBasicParseOptions), tempTree2.FilePath, Encoding.UTF8)

Syntax\SyntaxFactsTest.vb (1)

17Using stream = New StreamReader(GetType(SyntaxFactsTests).Assembly.GetManifestResourceStream("AllInOne.vb"), Encoding.UTF8)

Syntax\SyntaxTreeTests.vb (4)

125Dim oldText = SourceText.From("Class B : End Class", Encoding.Unicode, SourceHashAlgorithms.Default) 136Assert.Same(Encoding.Unicode, newText.Encoding) 165Dim oldText = SourceText.From("Class B : End Class", Encoding.Unicode, SourceHashAlgorithms.Default) 173Assert.Same(Encoding.Unicode, newText.Encoding)

Microsoft.CodeAnalysis.VisualBasic.Test.Utilities (8)

BasicTestSource.vb (2)

21Optional encoding As Encoding = Nothing, 24Dim sourceTest = SourceText.From(text, If(encoding, Encoding.UTF8), checksumAlgorithm)

CompilationTestUtils.vb (2)

636Return VisualBasicSyntaxTree.ParseText(SourceText.From(FilterString(programElement.Value), Encoding.UTF8, SourceHashAlgorithms.Default), path:=If(programElement.@name, "")) 653Dim text = SourceText.From(codeWithoutMarker, Encoding.UTF8)

ParserTestUtilities.vb (3)

108Public Function Parse(source As String, fileName As String, Optional options As VisualBasicParseOptions = Nothing, Optional encoding As Encoding = Nothing) As SyntaxTree 110encoding = Encoding.UTF8 527Public Overrides ReadOnly Property Encoding As Encoding

VBParser.vb (1)

18Dim tree = VisualBasicSyntaxTree.ParseText(SourceText.From(code, Encoding.UTF8, SourceHashAlgorithms.Default), _options, path:="")

Microsoft.CodeAnalysis.VisualBasic.Workspaces (3)

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

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

Workspace\LanguageServices\VisualBasicSyntaxTreeFactoryService.vb (1)

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

Microsoft.CodeAnalysis.Workspaces (80)

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

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

Log\AnalyzerNameForTelemetry.cs (1)

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

Serialization\SerializableSourceText.cs (2)

185var encoding = reader.ReadEncoding(); 194var encoding = reader.ReadEncoding();

Shared\Extensions\SourceTextExtensions.cs (1)

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

SourceGeneration\IRemoteSourceGenerationService.cs (1)

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

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

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

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

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

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

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

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

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

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

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

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

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

TemporaryStorage\TemporaryStorageService.cs (5)

114var size = Encoding.Unicode.GetMaxByteCount(text.Length); 120using var writer = new StreamWriter(stream, Encoding.Unicode); 185Encoding? encoding, 249Encoding? encoding, 255public Encoding? Encoding => encoding;

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

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

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

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

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

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

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

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

Workspace\Solution\DocumentState.cs (2)

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

Workspace\Solution\FileTextLoader.cs (2)

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

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

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

Workspace\Solution\SourceGeneratedDocumentIdentity.cs (3)

57hashInput.AddRange(Encoding.Unicode.GetBytes(assemblyNameToHash)); 59hashInput.AddRange(Encoding.Unicode.GetBytes(generatorIdentity.TypeName)); 61hashInput.AddRange(Encoding.Unicode.GetBytes(hintName));

Workspace\Solution\TextLoader.cs (1)

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

Workspace\WorkspaceFileTextLoader.cs (1)

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

Microsoft.CodeAnalysis.Workspaces.MSBuild (7)

MSBuild\MSBuildProjectLoader.Worker.cs (1)

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

MSBuild\MSBuildWorkspace.cs (5)

392var encoding = DetermineEncoding(text, document); 410var encoding = DetermineEncoding(text, document); 423private static Encoding? DetermineEncoding(SourceText text, TextDocument document) 485this.SaveDocumentText(info.Id, fullPath, text, text.Encoding ?? Encoding.UTF8); 489private void SaveDocumentText(DocumentId id, string fullPath, SourceText newText, Encoding encoding)

src\Workspaces\MSBuild\BuildHost\Rpc\Contracts\JsonSettings.cs (1)

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

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

MSBuild\ProjectFile\ProjectFileLoader.cs (1)

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

Rpc\Contracts\JsonSettings.cs (1)

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

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

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

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

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

Microsoft.CodeAnalysis.Workspaces.MSBuild.UnitTests (3)

VisualStudioMSBuildWorkspaceTests.cs (3)

2852var encoding = Encoding.BigEndianUnicode; 3295Assert.Equal(Encoding.GetEncoding(1254), text.Encoding);

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

GenerateFileForEachAdditionalFileWithContentsCommented.cs (1)

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

Microsoft.CodeAnalysis.Workspaces.UnitTests (59)

ObjectSerializationTests.cs (2)

653public void Encodings(Encoding original) 666var deserialized = reader.ReadEncoding();

Remote\ServiceDescriptorTests.cs (10)

152public void EncodingIsMessagePackSerializable(Encoding original) 160var deserialized = (Encoding)MessagePackSerializer.Deserialize(typeof(Encoding), stream, messagePackOptions); 181var original = Encoding.GetEncoding(Encoding.ASCII.CodePage, new TestEncoderFallback(), new TestDecoderFallback()); 187var deserialized = (Encoding)MessagePackSerializer.Deserialize(typeof(Encoding), stream, messagePackOptions);

SolutionTests\SolutionTests.cs (42)

SolutionTests\SolutionWithSourceGeneratorTests.cs (1)

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

UtilityTest\XmlDocumentationProviderTests.cs (1)

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

WorkspaceServiceTests\TemporaryStorageServiceTests.cs (1)

280var text = SourceText.From(new string(' ', 4096) + "public class A {}", Encoding.ASCII);

XxHash128Tests.cs (2)

38byte[] input = Encoding.ASCII.GetBytes(test.Ascii); 101byte[] asciiBytes = Encoding.ASCII.GetBytes(test.Ascii);

Microsoft.Data.Analysis (25)

DataFrame.IO.cs (10)

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

DataFrameColumns\ArrowStringDataFrameColumn.cs (6)

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

TextFieldParser.cs (9)

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

Microsoft.Data.Analysis.Tests (13)

ArrowStringColumnTests.cs (1)

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

DataFrame.IOTests.cs (1)

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

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

TextFieldParserTests.cs (2)

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

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

Csv\CsvSettings.cs (3)

11encoding: Encoding.UTF8, 16public CsvSettings(Encoding encoding, char delimiter, char textQualifier) 24public Encoding Encoding { get; private set; }

Program.cs (1)

208return new StreamWriter(OutFile, false, Encoding.UTF8);

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

src\AzureDevOpsNugetFeedAssetPublisher.cs (1)

55Convert.ToBase64String(Encoding.ASCII.GetBytes($":{_accessToken}")))

src\common\GeneralUtils.cs (2)

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

src\CreateAzureDevOpsFeed.cs (2)

142Convert.ToBase64String(Encoding.ASCII.GetBytes(string.Format("{0}:{1}", "", AzureDevOpsPersonalAccessToken)))); 149createFeedMessage.Content = new StringContent(createBody, Encoding.UTF8, "application/json");

src\model\SetupTargetFeedConfigV3.cs (1)

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

src\model\SetupTargetFeedConfigV4.cs (1)

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

src\PublishArtifactsInManifestBase.cs (2)

894Convert.ToBase64String(Encoding.ASCII.GetBytes(string.Format("{0}:{1}", "", 1345Convert.ToBase64String(Encoding.ASCII.GetBytes(string.Format("{0}:{1}", "", feedConfig.Token))));

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

src\ArReader.cs (6)

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

src\ArWriter.cs (7)

32Write(Encoding.ASCII.GetBytes(entry.Name.PadRight(16, ' ').Substring(0, 16))); 33Write(Encoding.ASCII.GetBytes(entry.Timestamp.ToString().PadRight(12, ' ').Substring(0, 12))); 34Write(Encoding.ASCII.GetBytes(entry.OwnerID.ToString().PadRight(6, ' ').Substring(0, 6))); 35Write(Encoding.ASCII.GetBytes(entry.GroupID.ToString().PadRight(6, ' ').Substring(0, 6))); 36Write(Encoding.ASCII.GetBytes(Convert.ToString(entry.Mode, 8).PadRight(8, ' ').Substring(0, 8))); 40Write(Encoding.ASCII.GetBytes(length.ToString().PadRight(10, ' ').Substring(0, 10))); 41Write(Encoding.ASCII.GetBytes("`\n"));

src\BuildFPMToolPreReqs.cs (1)

43string jsonFileText = File.ReadAllText(ConfigJsonFile, Encoding.UTF8);

src\CpioReader.cs (14)

src\CpioWriter.cs (1)

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

src\CreateChangelogFile.cs (1)

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

src\CreateControlFile.cs (1)

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

src\CreateDebPackage.cs (1)

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

src\CreateMD5SumsFile.cs (1)

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

src\GenerateGuidFromName.cs (1)

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

src\RpmBuilder.cs (1)

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

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

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

Microsoft.DotNet.Deployment.Tasks.Links (1)

src\AkaMSLinksManager.cs (1)

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

Microsoft.DotNet.Git.IssueManager (1)

Clients\AzureDevOpsClient.cs (1)

62Convert.ToBase64String(Encoding.ASCII.GetBytes(string.Format("{0}:{1}", "", personalAccessToken))));

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

IWorkItemDefinitionWithPayload.cs (1)

78IWorkItemDefinition WithSingleFilePayload(string name, string content, Encoding encoding);

Payloads\SingleFilePayload.cs (2)

19: this(name, content, Encoding.UTF8) 23public SingleFilePayload(string name, string content, Encoding encoding)

StorageHelpers\ContainerBase.cs (1)

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

WorkItemDefinition.cs (1)

95public IWorkItemDefinition WithSingleFilePayload(string name, string content, Encoding encoding)

Microsoft.DotNet.Helix.Sdk (5)

AzureDevOpsTask.cs (1)

64Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(Encoding.UTF8.GetBytes("unused:" + AccessToken))),

CommandPayload.cs (1)

13private static readonly Encoding s_utf8NoBom = new UTF8Encoding(false);

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.Open.Api.Tools.Tests (3)

OpenApiTestBase.cs (1)

141var byteArray = Encoding.ASCII.GetBytes(result.Item1);

src\Tools\Shared\TestHelpers\TestConsole.cs (2)

83public override Encoding Encoding => Encoding.Unicode;

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.DotNet.SignTool.Tests (4)

SignToolTests.cs (4)

3034using BinaryReader reader = new BinaryReader(inputStream, System.Text.Encoding.Default, true); 3035using BinaryWriter writer = new BinaryWriter(outputStream, System.Text.Encoding.Default, true); 3057using BinaryReader reader = new BinaryReader(inputStream, System.Text.Encoding.Default, true); 3058using BinaryWriter writer = new BinaryWriter(outputStream, System.Text.Encoding.Default, true);

Microsoft.DotNet.SwaggerGenerator.CodeGenerator (1)

ServiceClientCodeFactory.cs (1)

101public static readonly Encoding Utf8NoBom = new UTF8Encoding(false);

Microsoft.DotNet.XliffTasks (3)

Model\Document.cs (3)

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

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.Abstractions.Tests (1)

Contents\DataContentTests.cs (1)

261Assert.Equal("hello world", Encoding.ASCII.GetString(content.Data.ToArray()));

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)

18private static readonly byte[] _responseA = Encoding.UTF8.GetBytes("Content A"); 20private 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); 75bytesWritten = Encoding.UTF8.GetBytes(chars, value.Length, bytes, maxByteCount); 122Encoding.UTF8.GetString(ptr, bytes.Length);

src\Shared\ServerSentEvents\SseParser.cs (1)

27/// that decodes the data of each event using <see cref="Encoding.UTF8"/>'s GetString method.

Microsoft.Extensions.ApiDescription.Tool.Tests (2)

src\Tools\Shared\TestHelpers\TestConsole.cs (2)

83public override Encoding Encoding => Encoding.Unicode;

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

Internal\InbuiltTypeSerializer.cs (2)

34return Encoding.UTF8.GetString(source); 54Encoding.UTF8.GetBytes(value, target);

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.Diagnostics.ResourceMonitoring (5)

Linux\OSFileSystem.cs (5)

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

Microsoft.Extensions.Diagnostics.ResourceMonitoring.Tests (3)

Linux\OSFileSystemTests.cs (3)

94var fileBytes = Encoding.ASCII.GetBytes(fileContent); 145var fileBytes = Encoding.ASCII.GetBytes(fileContent); 194var fileBytes = Encoding.ASCII.GetBytes(fileContent.ToString());

Microsoft.Extensions.FileProviders.Embedded.Tests (1)

TestAssembly.cs (1)

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

Microsoft.Extensions.FileProviders.Physical (3)

PollingWildCardChangeToken.cs (3)

23private static readonly byte[] Separator = Encoding.Unicode.GetBytes("|"); 171int byteCount = Encoding.Unicode.GetByteCount(path); 177int length = Encoding.Unicode.GetBytes(path, 0, path.Length, _byteBuffer, 0);

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)

103return Encoding.UTF8.GetString(memory[..charsWritten].Span);

Logging\Internal\HttpResponseBodyReader.cs (1)

160return Encoding.UTF8.GetString(memory[..bytesRead].Span);

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.Identity.Core (2)

Rfc6238AuthenticationService.cs (1)

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

UserManager.cs (1)

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

Microsoft.Extensions.Logging.Console (2)

JsonConsoleFormatter.cs (2)

100var logMessageBuffer = ArrayPool<char>.Shared.Rent(Encoding.UTF8.GetMaxCharCount(messageBytes.Length)); 104var 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.Roslyn3.11.cs (1)

39context.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 (7)

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

src\Tools\Shared\TestHelpers\TestConsole.cs (2)

83public override Encoding Encoding => Encoding.Unicode;

TemporaryFileProvider.cs (1)

21File.WriteAllText(Path.Combine(Root, filename), contents, Encoding.UTF8);

Microsoft.Extensions.Telemetry.Tests (2)

Latency\Internal\LatencyConsoleExporterTests.cs (2)

160public override Encoding Encoding => 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 (3)

Text\CountingWriter.cs (1)

16 public override Encoding Encoding => _writer.Encoding;

Text\XmlAttributedTextReader.cs (1)

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

Text\XmlAttributedTextWriter.cs (1)

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

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

Data\ModelLoadContext.cs (1)

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

Data\ModelLoading.cs (2)

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

Data\ModelSaveContext.cs (2)

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

Data\ModelSaving.cs (1)

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

Utilities\Stream.cs (2)

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

Utilities\TextReaderStream.cs (4)

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

Microsoft.ML.Data (10)

Commands\SavePredictorCommand.cs (1)

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

DataLoadSave\Binary\BinaryLoader.cs (2)

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

DataLoadSave\Binary\BinarySaver.cs (3)

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

DataLoadSave\Binary\CodecFactory.cs (3)

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

DataLoadSave\Transpose\TransposeSaver.cs (1)

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

Microsoft.ML.FastTree (4)

Utils\ToByteArrayExtensions.cs (4)

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

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.PerformanceTests (1)

Helpers\EmptyWriter.cs (1)

16public override Encoding Encoding => null;

Microsoft.ML.Samples (1)

Dynamic\TensorFlow\ImageClassification.cs (1)

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

Microsoft.ML.Samples.GPU (1)

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

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

Microsoft.ML.TestFramework (2)

BaseTestBaseline.cs (1)

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

BytesStreamSource.cs (1)

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

Microsoft.ML.TestFrameworkCommon (2)

TestLogger.cs (2)

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

Microsoft.ML.Tokenizers (37)

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.netcoreapp.cs (4)

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

Utils\OrdinalUtf8StringComparer.cs (2)

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

Microsoft.ML.Tokenizers.Tests (14)

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

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

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

Microsoft.Net.Http.Headers (12)

ContentDispositionHeaderValue.cs (7)

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

MediaTypeHeaderValue.cs (3)

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

src\Shared\HttpRuleParser.cs (2)

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

Microsoft.VisualBasic.Core (16)

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

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

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

347Protected m_Encoding As Encoding

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

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

Microsoft\VisualBasic\Strings.vb (5)

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

Microsoft.VisualBasic.Forms (10)

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

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

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

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

Microsoft.VisualBasic.Forms.Tests (8)

System\Windows\Forms\FileLogTraceListenerTests.vb (3)

68listener.Encoding.Should.Be(Encoding.UTF8) 69listener.Encoding = Encoding.ASCII 70listener.Encoding.Should.Be(Encoding.ASCII)

System\Windows\Forms\FileSystemProxyTests.vb (5)

273encoding:=Encoding.ASCII) 278encoding:=Encoding.ASCII) 323Using fileReader As IO.StreamReader = _fileSystem.OpenTextFileReader(fileA, Encoding.ASCII) 391_fileSystem.WriteAllText(fileA, "A", append:=False, Encoding.UTF8) 392Dim text As String = _fileSystem.ReadAllText(fileA, Encoding.UTF8)

Microsoft.VisualStudio.LanguageServices (6)

CodeMarkers\ManagedCodeMarkers.cs (2)

308var encoding = System.Text.Encoding.Unicode;

ColorSchemes\ColorSchemeApplier.RegistryItemConverter.cs (1)

100bytes.Write(Encoding.ASCII.GetBytes(color.Name), 0, color.Name.Length);

Implementation\AbstractEditorFactory.cs (1)

370using var textWriter = new StreamWriter(filePath, append: false, encoding: formattedText.Encoding ?? Encoding.UTF8);

ProjectSystem\VisualStudioWorkspaceImpl.cs (2)

956using var writer = new StreamWriter(documentInfo.FilePath, append: false, encoding: text.Encoding ?? Encoding.UTF8); 1000using var writer = new StreamWriter(filePath, append: false, encoding: initialText.Encoding ?? Encoding.UTF8);

Microsoft.VisualStudio.LanguageServices.CSharp.UnitTests (3)

DocumentOutline\DocumentOutlineTestsBase.cs (1)

110solution = solution.WithDocumentText(document.Id, SourceText.From(documentText.ToString(), System.Text.Encoding.UTF8));

PersistentStorage\AbstractPersistentStorageTests.cs (2)

40private readonly Encoding _encoding = Encoding.UTF8;

Microsoft.VisualStudio.LanguageServices.LiveShare (1)

Client\Projects\WorkspaceFileTextLoaderNoException.cs (1)

23public WorkspaceFileTextLoaderNoException(SolutionServices services, string path, Encoding defaultEncoding)

MSBuild (11)

AutomaticEncodingRestorer.cs (2)

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

CommunicationsUtilities.cs (1)

183byte[] utf8 = Encoding.UTF8.GetBytes(input);

FileUtilities.cs (2)

InterningBinaryReader.cs (3)

62: base(input, Encoding.UTF8) 71_decoder = Encoding.UTF8.GetDecoder(); 287_byteBuffer ??= new byte[Encoding.UTF8.GetMaxByteCount(MaxCharsBuffer)];

XMake.cs (3)

1934Console.OutputEncoding = Encoding.UTF8; 1936Console.InputEncoding = Encoding.UTF8; 1973Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);

MSBuildTaskHost (6)

CommunicationsUtilities.cs (1)

183byte[] utf8 = Encoding.UTF8.GetBytes(input);

FileUtilities.cs (2)

InterningBinaryReader.cs (3)

62: base(input, Encoding.UTF8) 71_decoder = Encoding.UTF8.GetDecoder(); 287_byteBuffer ??= new byte[Encoding.UTF8.GetMaxByteCount(MaxCharsBuffer)];

mscorlib (1)

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

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

netstandard (1)

netstandard.cs (1)

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

PlaintextApp (1)

Startup.cs (1)

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

PresentationBuildTasks (3)

Microsoft\Build\Tasks\Windows\UpdateManifestForBrowserApplication.cs (1)

111manifestWriter = new XmlTextWriter(appManifestFile, System.Text.Encoding.UTF8)

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

21public BamlBinaryWriter(Stream stream, Encoding code)

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

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

PresentationCore (4)

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

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

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

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

PresentationFramework (22)

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

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

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

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

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

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

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

307internal Encoding CurrentEncoding 594private Encoding _currentEncoding;

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

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

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

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

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

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

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

18public BamlBinaryReader(Stream stream, Encoding code)

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

21public BamlBinaryWriter(Stream stream, Encoding code)

PresentationUI (1)

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

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

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

src\Compilers\Core\CommandLine\BuildProtocol.cs (4)

src\Compilers\Core\CommandLine\CompilerServerLogger.cs (1)

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

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

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

Roslyn.Diagnostics.Analyzers (3)

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

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

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)

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

Roslyn.Test.PdbUtilities (5)

Reader\PdbValidation.cs (1)

589Assert.Equal(Encoding.UTF8.GetByteCount(pdbPath) + 1, paddedPathLength);

Reader\Token2SourceLineExporter.cs (4)

257value = Encoding.UTF8.GetString(_buffer, _offset, len); 268value = Encoding.UTF8.GetString(_buffer, _offset, len); 308string result = Encoding.Unicode.GetString(_buffer, _offset, len); 1132Encoding = Encoding.UTF8,

Roslyn.VisualStudio.Next.UnitTests (13)

Remote\SnapshotSerializationTests.cs (3)

607var sourceText = SourceText.From("Hello", Encoding.UTF8); 748private readonly Encoding _real = Encoding.UTF8;

Services\ServiceHubServicesTests.cs (9)

513private static SourceText CreateText(string content, Encoding encoding = null, SourceHashAlgorithm checksumAlgorithm = SourceHashAlgorithm.Sha1) 514=> SourceText.From(content, encoding ?? Encoding.UTF8, checksumAlgorithm); 602[("SG.cs", CreateText("X", Encoding.ASCII))], 603[("SG.cs", CreateText("X", Encoding.UTF8))]); 610[("SG.cs", CreateText("X", Encoding.UTF8, checksumAlgorithm: SourceHashAlgorithm.Sha1))], 611[("SG.cs", CreateText("X", Encoding.UTF8, checksumAlgorithm: SourceHashAlgorithm.Sha256))]); 737return ImmutableArray.Create(("hint", SourceText.From($"// generated document {callCount}", Encoding.UTF8))); 821return ImmutableArray.Create(("hint", SourceText.From($"// generated document {callCount}", Encoding.UTF8))); 876return ImmutableArray.Create(("hint", SourceText.From($"// generated document {callCount}", Encoding.UTF8)));

UnifiedSettings\UnifiedSettingsTests.cs (1)

282var fileBytes = Encoding.ASCII.GetBytes(registrationFile);

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)

420var reader = new StreamReader(stream, Encoding.UTF8); 427var 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 (6)

Pipe\PipeWeatherStreamFormatter.cs (6)

55var utf8 = Encoding.UTF8; 57var convertedBytes = Encoding.Convert(Encoding.UTF8, Encoding.ASCII, encodedBytes); 59await sw.WriteLineAsync(Encoding.ASCII.GetString(convertedBytes));

Sockets.BindTests (4)

src\Servers\Kestrel\shared\test\StreamBackedTestConnection.cs (4)

Sockets.FunctionalTests (16)

src\Servers\Kestrel\shared\test\StreamBackedTestConnection.cs (4)

src\Servers\Kestrel\test\FunctionalTests\MaxRequestBufferSizeTests.cs (2)

391using (var writer = new StreamWriter(stream, Encoding.ASCII, bufferSize: 1024, leaveOpen: true)) 404var expectedBytes = Encoding.ASCII.GetBytes(expectedSubstring);

src\Servers\Kestrel\test\FunctionalTests\RequestTests.cs (6)

119socket.Send(Encoding.ASCII.GetBytes("POST / HTTP/1.1\r\nHost: \r\n")); 120socket.Send(Encoding.ASCII.GetBytes($"Content-Length: {contentLength}\r\n\r\n")); 634socket.Send(Encoding.ASCII.GetBytes("GET / HTTP/1.1\r\nHost:\r\nContent-Length: 1\r\n\r\n")); 680socket.Send(Encoding.ASCII.GetBytes("GET / HTTP/1.1\r\nHost:\r\n\r\n")); 774socket.Send(Encoding.ASCII.GetBytes("GET / HTTP/1.1\r\nHost:\r\n\r\n")); 1203var expectedBytes = Encoding.ASCII.GetBytes(expectedSubstring);

src\Servers\Kestrel\test\FunctionalTests\ResponseTests.cs (1)

701var request = Encoding.ASCII.GetBytes("GET / HTTP/1.1\r\nHost:\r\n\r\n");

src\Servers\Kestrel\test\FunctionalTests\UnixDomainSocketsTests.cs (3)

101var data = Encoding.ASCII.GetBytes("Hello World"); 169var httpRequest = Encoding.ASCII.GetBytes("GET / HTTP/1.1\r\nHost:\r\nConnection: close\r\n\r\n"); 184var httpResponse = Encoding.ASCII.GetString(readBuffer, 0, read);

Stress.ApiService (1)

ConsoleStresser.cs (1)

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

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

System\Configuration\BaseConfigurationRecord.cs (2)

3705StreamEncoding = Encoding.UTF8; 3714internal Encoding StreamEncoding { get; set; }

System\Configuration\DpapiProtectedConfigurationProvider.cs (2)

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

System\Configuration\ImplicitMachineConfigHost.cs (1)

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

System\Configuration\MgmtConfigurationRecord.cs (2)

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

System\Configuration\XmlUtil.cs (1)

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

System.Console (32)

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

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

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

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

System\Console.cs (8)

30private static Encoding? s_inputEncoding; 31private static Encoding? s_outputEncoding; 70public static Encoding InputEncoding 74Encoding? encoding = Volatile.Read(ref s_inputEncoding); 97Volatile.Write(ref s_inputEncoding, (Encoding)value.Clone()); 107public static Encoding OutputEncoding 111Encoding? encoding = Volatile.Read(ref s_outputEncoding); 151Volatile.Write(ref s_outputEncoding, (Encoding)value.Clone());

System\ConsolePal.Unix.cs (10)

62public static Encoding InputEncoding 67public static Encoding OutputEncoding 695private static Encoding GetConsoleEncoding() 697Encoding? enc = EncodingHelper.GetEncodingFromCharset(); 700Encoding.Default; 724public static void SetConsoleInputEncoding(Encoding enc) 730public static void SetConsoleOutputEncoding(Encoding enc) 1125data = stackalloc byte[Encoding.UTF8.GetMaxByteCount(value.Length)]; 1126int bytesToWrite = Encoding.UTF8.GetBytes(value, data); 1131data = Encoding.UTF8.GetBytes(value);

System\IO\CachedConsoleStream.cs (2)

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

System\IO\StdInReader.cs (2)

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

System\TermInfo.cs (1)

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

System\TermInfo.Database.cs (3)

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

System.Data.Common (5)

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

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

System\Data\SQLTypes\SqlXml.cs (1)

182writerSettings.Encoding = Encoding.GetEncoding("utf-16");

System.Data.Odbc (10)

System\Data\Odbc\OdbcConnection.cs (4)

399value = (BitConverter.IsLittleEndian ? Encoding.Unicode : Encoding.BigEndianUnicode).GetString(buffer, 0, Math.Min(cbActual, buffer.Length)); 501value = (BitConverter.IsLittleEndian ? Encoding.Unicode : Encoding.BigEndianUnicode).GetString(buffer, 0, Math.Min(cbActual, buffer.Length));

System\Data\Odbc\OdbcParameter.cs (6)

370cch = System.Text.Encoding.Default.GetMaxByteCount(cch); 384cch = System.Text.Encoding.Default.GetMaxByteCount(cch); 744Encoding cpe = System.Text.Encoding.GetEncoding(culInfo.TextInfo.ANSICodePage); 971Encoding cpe = System.Text.Encoding.GetEncoding(culInfo.TextInfo.ANSICodePage);

System.Diagnostics.Process (14)

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\AsyncStreamReader.cs (1)

48internal AsyncStreamReader(Stream stream, Action<string?> callback, Encoding encoding)

System\Diagnostics\Process.Linux.cs (1)

348string argString = Encoding.UTF8.GetString(arg.Slice(nameStart));

System\Diagnostics\Process.Unix.cs (3)

470startInfo.StandardInputEncoding ?? Encoding.Default, StreamBufferSize) 477startInfo.StandardOutputEncoding ?? Encoding.Default, true, StreamBufferSize); 483startInfo.StandardErrorEncoding ?? Encoding.Default, true, StreamBufferSize);

System\Diagnostics\ProcessStartInfo.cs (3)

120public Encoding? StandardInputEncoding { get; set; } 122public Encoding? StandardErrorEncoding { get; set; } 124public Encoding? StandardOutputEncoding { get; set; }

System.Drawing.Common.Tests (17)

System\Drawing\ImageTests.cs (17)

System.Formats.Asn1 (12)

System\Formats\Asn1\AsnCharacterStringEncodings.cs (4)

22internal static Encoding GetEncoding(UniversalTagNumber encodingType) => 35internal static int GetByteCount(this Encoding encoding, ReadOnlySpan<char> str) 52internal static int GetBytes(this Encoding encoding, ReadOnlySpan<char> chars, Span<byte> bytes) 421private static readonly Encoding s_latin1Encoding = GetEncoding("iso-8859-1");

System\Formats\Asn1\AsnDecoder.Text.cs (5)

251Text.Encoding encoding = AsnCharacterStringEncodings.GetEncoding(encodingType); 322Text.Encoding encoding = AsnCharacterStringEncodings.GetEncoding(encodingType); 390Text.Encoding encoding, 433Text.Encoding encoding, 485Text.Encoding encoding,

System\Formats\Asn1\AsnWriter.Text.cs (3)

76Text.Encoding encoding = AsnCharacterStringEncodings.GetEncoding(encodingType); 81private void WriteCharacterStringCore(Asn1Tag tag, Text.Encoding encoding, ReadOnlySpan<char> str) 113private void WriteConstructedCerCharacterString(Asn1Tag tag, Text.Encoding encoding, ReadOnlySpan<char> str, int size)

System.Formats.Cbor (15)

System\Formats\Cbor\CborConformanceLevel.cs (1)

117public static Encoding GetUtf8Encoding(CborConformanceMode conformanceMode)

System\Formats\Cbor\CborHelpers.netcoreapp.cs (5)

16public static int GetBytes(Encoding encoding, ReadOnlySpan<char> source, Span<byte> destination) 19public static int GetByteCount(Encoding encoding, ReadOnlySpan<char> chars) 22public static int GetChars(Encoding encoding, ReadOnlySpan<byte> source, Span<char> destination) 25public static int GetCharCount(Encoding encoding, ReadOnlySpan<byte> source) 28public static string GetString(Encoding encoding, ReadOnlySpan<byte> bytes)

System\Formats\Cbor\Reader\CborReader.String.cs (8)

190Encoding utf8Encoding = CborConformanceModeHelpers.GetUtf8Encoding(ConformanceMode); 236Encoding utf8Encoding = CborConformanceModeHelpers.GetUtf8Encoding(ConformanceMode); 281Encoding encoding = CborConformanceModeHelpers.GetUtf8Encoding(ConformanceMode); 379Encoding utf8Encoding = CborConformanceModeHelpers.GetUtf8Encoding(ConformanceMode); 397static void BuildString(Span<char> target, (List<(int Offset, int Length)> ranges, ReadOnlyMemory<byte> source, Encoding utf8Encoding) input) 415Encoding utf8Encoding = CborConformanceModeHelpers.GetUtf8Encoding(ConformanceMode); 498Encoding utf8Encoding = CborConformanceModeHelpers.GetUtf8Encoding(ConformanceMode); 506private static int ValidateUtf8AndGetCharCount(ReadOnlySpan<byte> buffer, Encoding utf8Encoding)

System\Formats\Cbor\Writer\CborWriter.String.cs (1)

123Encoding utf8Encoding = CborConformanceModeHelpers.GetUtf8Encoding(ConformanceMode);

System.Formats.Tar (19)

System\Formats\Tar\TarHeader.Read.cs (4)

457_magic = Encoding.ASCII.GetString(magic); 510_version = Encoding.ASCII.GetString(version); 740key = Encoding.UTF8.GetString(keySlice); 741value = Encoding.UTF8.GetString(valueSlice);

System\Formats\Tar\TarHeader.Write.cs (12)

System\Formats\Tar\TarHelpers.cs (3)

273private static string GetTrimmedString(ReadOnlySpan<byte> buffer, Encoding encoding) 303internal static string GetTrimmedAsciiString(ReadOnlySpan<byte> buffer) => GetTrimmedString(buffer, Encoding.ASCII); 307internal static string GetTrimmedUtf8String(ReadOnlySpan<byte> buffer) => GetTrimmedString(buffer, Encoding.UTF8);

System.IO.Compression (17)

System\IO\Compression\ZipArchive.Async.cs (1)

65public static async Task<ZipArchive> CreateAsync(Stream stream, ZipArchiveMode mode, bool leaveOpen, Encoding? entryNameEncoding, CancellationToken cancellationToken = default)

System\IO\Compression\ZipArchive.cs (8)

32private Encoding? _entryNameAndCommentEncoding; 121public ZipArchive(Stream stream, ZipArchiveMode mode, bool leaveOpen, Encoding? entryNameEncoding) 181private ZipArchive(ZipArchiveMode mode, bool leaveOpen, Encoding? entryNameEncoding, Stream? backingStream, Stream archiveStream) 205/// The comment encoding is determined by the <c>entryNameEncoding</c> parameter of the <see cref="ZipArchive(Stream,ZipArchiveMode,bool,Encoding?)"/> constructor. 211get => (EntryNameAndCommentEncoding ?? Encoding.UTF8).GetString(_archiveComment); 346internal Encoding? EntryNameAndCommentEncoding 368(value.Equals(Encoding.BigEndianUnicode) 369|| value.Equals(Encoding.Unicode)))

System\IO\Compression\ZipArchiveEntry.cs (4)

208///The comment encoding is determined by the <c>entryNameEncoding</c> parameter of the <see cref="ZipArchive(Stream,ZipArchiveMode,bool,Encoding?)"/> constructor. 378Encoding readEntryStringEncoding = 380? Encoding.UTF8 381: _archive?.EntryNameAndCommentEncoding ?? Encoding.UTF8;

System\IO\Compression\ZipHelper.cs (4)

22internal static Encoding GetEncoding(string text) 29return Encoding.UTF8; 32return Encoding.ASCII; 198internal static byte[] GetEncodedTruncatedBytesFromString(string? text, Encoding? encoding, int maxBytes, out bool isUTF8)

System.IO.Compression.ZipFile (18)

System\IO\Compression\ZipFile.Create.Async.cs (5)

152public static async Task<ZipArchive> OpenAsync(string archiveFileName, ZipArchiveMode mode, Encoding? entryNameEncoding, CancellationToken cancellationToken = default) 335CompressionLevel compressionLevel, bool includeBaseDirectory, Encoding? entryNameEncoding, CancellationToken cancellationToken = default) => 422CompressionLevel compressionLevel, bool includeBaseDirectory, Encoding? entryNameEncoding, CancellationToken cancellationToken = default) => 426CompressionLevel? compressionLevel, bool includeBaseDirectory, Encoding? entryNameEncoding, CancellationToken cancellationToken) 445CompressionLevel? compressionLevel, bool includeBaseDirectory, Encoding? entryNameEncoding, CancellationToken cancellationToken)

System\IO\Compression\ZipFile.Create.cs (5)

144public static ZipArchive Open(string archiveFileName, ZipArchiveMode mode, Encoding? entryNameEncoding) 319CompressionLevel compressionLevel, bool includeBaseDirectory, Encoding? entryNameEncoding) => 400CompressionLevel compressionLevel, bool includeBaseDirectory, Encoding? entryNameEncoding) => 404CompressionLevel? compressionLevel, bool includeBaseDirectory, Encoding? entryNameEncoding) 418CompressionLevel? compressionLevel, bool includeBaseDirectory, Encoding? entryNameEncoding)

System\IO\Compression\ZipFile.Extract.Async.cs (4)

134public static Task ExtractToDirectoryAsync(string sourceArchiveFileName, string destinationDirectoryName, Encoding? entryNameEncoding, CancellationToken cancellationToken = default) => 191public static async Task ExtractToDirectoryAsync(string sourceArchiveFileName, string destinationDirectoryName, Encoding? entryNameEncoding, bool overwriteFiles, CancellationToken cancellationToken = default) 301public static Task ExtractToDirectoryAsync(Stream source, string destinationDirectoryName, Encoding? entryNameEncoding, CancellationToken cancellationToken = default) => 341public static async Task ExtractToDirectoryAsync(Stream source, string destinationDirectoryName, Encoding? entryNameEncoding, bool overwriteFiles, CancellationToken cancellationToken = default)

System\IO\Compression\ZipFile.Extract.cs (4)

126public static void ExtractToDirectory(string sourceArchiveFileName, string destinationDirectoryName, Encoding? entryNameEncoding) => 181public static void ExtractToDirectory(string sourceArchiveFileName, string destinationDirectoryName, Encoding? entryNameEncoding, bool overwriteFiles) 282public static void ExtractToDirectory(Stream source, string destinationDirectoryName, Encoding? entryNameEncoding) => 320public static void ExtractToDirectory(Stream source, string destinationDirectoryName, Encoding? entryNameEncoding, bool overwriteFiles)

System.IO.FileSystem.Watcher (1)

System\IO\FileSystemWatcher.Linux.cs (1)

865Encoding.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.IO.Ports (5)

System\IO\Ports\SerialPort.cs (5)

43private Encoding _encoding = Encoding.ASCII; // ASCII is default encoding for modem communication, etc. 44private Decoder _decoder = Encoding.ASCII.GetDecoder(); 45private int _maxByteCountForSingleChar = Encoding.ASCII.GetMaxByteCount(1); 293public Encoding Encoding

System.Memory (24)

System\Text\EncodingExtensions.cs (24)

System.Memory.Data (2)

System\BinaryData.cs (2)

144_bytes = Encoding.UTF8.GetBytes(data); 430return Encoding.UTF8.GetString(ptr, span.Length);

System.Net.Http (119)

src\libraries\Common\src\System\Net\Http\aspnetcore\Http2\Hpack\H2StaticTable.Http2.cs (2)

102Encoding.ASCII.GetBytes(name), 103value.Length != 0 ? Encoding.ASCII.GetBytes(value) : Array.Empty<byte>());

src\libraries\Common\src\System\Net\Http\aspnetcore\Http2\Hpack\HeaderField.cs (2)

45return Encoding.Latin1.GetString(Name) + ": " + Encoding.Latin1.GetString(Value);

src\libraries\Common\src\System\Net\Http\aspnetcore\Http2\Hpack\HPackEncoder.cs (12)

src\libraries\Common\src\System\Net\Http\aspnetcore\Http2\Hpack\StatusCodes.cs (1)

145return Encoding.ASCII.GetBytes(statusCode.ToString(CultureInfo.InvariantCulture));

src\libraries\Common\src\System\Net\Http\aspnetcore\Http3\QPack\H3StaticTable.Http3.cs (2)

157=> new HeaderField(Encoding.ASCII.GetBytes(name), Encoding.ASCII.GetBytes(value));

src\libraries\Common\src\System\Net\Http\aspnetcore\Http3\QPack\HeaderField.cs (2)

35return Encoding.ASCII.GetString(Name) + ": " + Encoding.ASCII.GetString(Value);

src\libraries\Common\src\System\Net\Http\aspnetcore\Http3\QPack\QPackEncoder.cs (9)

System\Net\Http\HeaderEncodingSelector.cs (4)

9/// Represents a method that specifies the <see cref="Encoding"/> to use when interpreting header values. 11/// <param name="headerName">Name of the header to specify the <see cref="Encoding"/> for.</param> 14/// <returns><see cref="Encoding"/> to use or <see langword="null"/> to use the default behavior.</returns> 15public delegate Encoding? HeaderEncodingSelector<TContext>(string headerName, TContext context);

System\Net\Http\Headers\ContentDispositionHeaderValue.cs (5)

439byte[] buffer = Encoding.UTF8.GetBytes(input); 473Encoding encoding = Encoding.GetEncoding(processedInput[parts[1]]); 514Encoding encoding = Encoding.GetEncoding(encodingString);

System\Net\Http\Headers\HeaderDescriptor.cs (1)

132public string GetHeaderValue(ReadOnlySpan<byte> headerValue, Encoding? valueEncoding)

System\Net\Http\Headers\HeaderUtilities.cs (3)

71byte[] utf8bytes = ArrayPool<byte>.Shared.Rent(Encoding.UTF8.GetMaxByteCount(input.Length)); 72int utf8length = Encoding.UTF8.GetBytes(input, 0, input.Length, utf8bytes, 0); 85Encoding.ASCII.GetChars(utf8.Slice(0, length), builder.AppendSpan(length));

System\Net\Http\Headers\HttpHeaderParser.cs (1)

41SeparatorBytes = Encoding.ASCII.GetBytes(separator);

System\Net\Http\Headers\KnownHeader.cs (1)

31int asciiBytes = Encoding.ASCII.GetBytes(name, asciiBytesWithColonSpace);

System\Net\Http\Headers\UriHeaderParser.cs (2)

78Encoding decoder = Encoding.GetEncoding("utf-8", EncoderFallback.ExceptionFallback, DecoderFallback.ExceptionFallback);

System\Net\Http\HttpContent.cs (16)

25internal static readonly Encoding DefaultStringEncoding = Encoding.UTF8; 41AssertEncodingConstants(Encoding.UTF8, UTF8CodePage, UTF8Preamble); 44AssertEncodingConstants(Encoding.UTF32, UTF32CodePage, UTF32Preamble); 46AssertEncodingConstants(Encoding.Unicode, UnicodeCodePage, UnicodePreamble); 48AssertEncodingConstants(Encoding.BigEndianUnicode, BigEndianUnicodeCodePage, BigEndianUnicodePreamble); 51private static void AssertEncodingConstants(Encoding encoding, int codePage, ReadOnlySpan<byte> preamble) 118Encoding? encoding = null; 134encoding = Encoding.GetEncoding(charset.Substring(1, charset.Length - 2)); 138encoding = Encoding.GetEncoding(charset); 699private static int GetPreambleLength(ReadOnlySpan<byte> data, Encoding encoding) 723private static bool TryDetectEncoding(ReadOnlySpan<byte> data, [NotNullWhen(true)] out Encoding? encoding, out int preambleLength) 727encoding = Encoding.UTF8; 734encoding = Encoding.UTF32; 741encoding = Encoding.Unicode; 748encoding = Encoding.BigEndianUnicode;

System\Net\Http\HttpRuleParser.cs (3)

30internal static Encoding DefaultHttpEncoding => Encoding.Latin1; 53return Encoding.ASCII.GetString(input);

System\Net\Http\MultipartContent.cs (4)

143/// Gets or sets a callback that returns the <see cref="Encoding"/> to decode the value for the specified response header name, 319Encoding headerValueEncoding = HeaderEncodingSelector?.Invoke(headerPair.Key, content) ?? HttpRuleParser.DefaultHttpEncoding; 376Encoding headerValueEncoding = HeaderEncodingSelector?.Invoke(headerPair.Key, content) ?? HttpRuleParser.DefaultHttpEncoding; 642private static void WriteToStream(Stream stream, string content, Encoding encoding)

System\Net\Http\SocketsHttpHandler\AuthenticationHelper.cs (1)

182string base64AuthString = Convert.ToBase64String(Encoding.UTF8.GetBytes(authString));

System\Net\Http\SocketsHttpHandler\AuthenticationHelper.Digest.cs (1)

216byte[] dataBytes = Encoding.UTF8.GetBytes(data);

System\Net\Http\SocketsHttpHandler\ChunkedEncodingReadStream.cs (1)

389throw new HttpIOException(HttpRequestError.InvalidResponse, SR.Format(SR.net_http_invalid_response_chunk_terminator_invalid, Encoding.ASCII.GetString(currentLine)));

System\Net\Http\SocketsHttpHandler\ConnectionPool\HttpConnectionPool.cs (2)

187Encoding.ASCII.GetBytes(hostHeader, hostHeaderLine.AsSpan(6)); 192Debug.Assert(Encoding.ASCII.GetString(_hostHeaderLineBytes) == $"Host: {hostHeader}\r\n");

System\Net\Http\SocketsHttpHandler\ConnectionPool\HttpConnectionPool.Http2.cs (1)

55_http2AltSvcOriginUri = Encoding.ASCII.GetBytes(sb.ToString());

System\Net\Http\SocketsHttpHandler\Http2Connection.cs (9)

444string response = Encoding.ASCII.GetString(_incomingBuffer.ActiveSpan.Slice(0, Math.Min(20, _incomingBuffer.ActiveLength))); 770string altSvcHeaderValue = Encoding.ASCII.GetString(span); 1376private void WriteLiteralHeader(string name, ReadOnlySpan<string> values, Encoding? valueEncoding, ref ArrayBuffer headerBuffer) 1389private void WriteLiteralHeaderValues(ReadOnlySpan<string> values, byte[]? separator, Encoding? valueEncoding, ref ArrayBuffer headerBuffer) 1391if (NetEventSource.Log.IsEnabled()) Trace($"{nameof(values)}={string.Join(Encoding.ASCII.GetString(separator ?? []), values.ToArray())}"); 1402private void WriteLiteralHeaderValue(string value, Encoding? valueEncoding, ref ArrayBuffer headerBuffer) 1441Encoding? valueEncoding = encodingSelector?.Invoke(header.Key.Name, request); 1537Encoding? protocolEncoding = _pool.Settings._requestHeaderEncodingSelector?.Invoke(":protocol", request); 1552Encoding? cookieEncoding = _pool.Settings._requestHeaderEncodingSelector?.Invoke(KnownHeaders.Cookie.Name, request);

System\Net\Http\SocketsHttpHandler\Http2Stream.cs (4)

679if (NetEventSource.Log.IsEnabled()) Trace($"{descriptor.Name}: {Encoding.ASCII.GetString(value)}"); 704Encoding? valueEncoding = _connection._pool.Settings._responseHeaderEncodingSelector?.Invoke(descriptor.Name, _request); 744if (NetEventSource.Log.IsEnabled()) Trace($"Invalid response pseudo-header '{Encoding.ASCII.GetString(name)}'."); 754throw new HttpRequestException(HttpRequestError.InvalidResponse, SR.Format(SR.net_http_invalid_response_header_name, Encoding.ASCII.GetString(name)));

System\Net\Http\SocketsHttpHandler\Http3RequestStream.cs (9)

675Encoding? valueEncoding = _connection.Pool.Settings._requestHeaderEncodingSelector?.Invoke(HttpKnownHeaderNames.Cookie, request); 734Encoding? valueEncoding = encodingSelector?.Invoke(header.Key.Name, _request); 791private void BufferLiteralHeaderWithStaticNameReference(int nameIndex, string value, Encoding? valueEncoding = null) 801private void BufferLiteralHeaderWithoutNameReference(string name, ReadOnlySpan<string> values, byte[] separator, Encoding? valueEncoding) 811private void BufferLiteralHeaderWithoutNameReference(string name, string value, Encoding? valueEncoding) 821private void BufferLiteralHeaderValues(ReadOnlySpan<string> values, byte[]? separator, Encoding? valueEncoding) 957throw new HttpRequestException(HttpRequestError.InvalidResponse, SR.Format(SR.net_http_invalid_response_header_name, Encoding.ASCII.GetString(name))); 1039return HttpConnectionBase.ParseStatusCode(Encoding.ASCII.GetBytes(value)); 1089Encoding? encoding = _connection.Pool.Settings._responseHeaderEncodingSelector?.Invoke(descriptor.Name, _request);

System\Net\Http\SocketsHttpHandler\HttpConnection.cs (10)

439Encoding? valueEncoding = encodingSelector?.Invoke(header.Key.Name, _currentRequest); 502private void WriteString(string s, Encoding? encoding) 1065throw new HttpRequestException(HttpRequestError.InvalidResponse, SR.Format(SR.net_http_invalid_response_status_line, Encoding.ASCII.GetString(line))); 1086throw new HttpRequestException(HttpRequestError.InvalidResponse, SR.Format(SR.net_http_invalid_response_status_line, Encoding.ASCII.GetString(line))); 1094throw new HttpRequestException(HttpRequestError.InvalidResponse, SR.Format(SR.net_http_invalid_response_status_code, Encoding.ASCII.GetString(line.Slice(9, 3)))); 1119throw new HttpRequestException(HttpRequestError.InvalidResponse, SR.Format(SR.net_http_invalid_response_status_reason, Encoding.ASCII.GetString(reasonBytes.ToArray())), formatEx); 1125throw new HttpRequestException(HttpRequestError.InvalidResponse, SR.Format(SR.net_http_invalid_response_status_line, Encoding.ASCII.GetString(line))); 1224throw new HttpRequestException(HttpRequestError.InvalidResponse, SR.Format(SR.net_http_invalid_response_header_line, Encoding.ASCII.GetString(buffer.Slice(0, newLineIndex)))); 1276Encoding? valueEncoding = _pool.Settings._responseHeaderEncodingSelector?.Invoke(descriptor.Name, _currentRequest!); 1326throw new HttpRequestException(HttpRequestError.InvalidResponse, SR.Format(SR.net_http_invalid_response_header_name, Encoding.ASCII.GetString(name)));

System\Net\Http\SocketsHttpHandler\HttpConnectionBase.cs (3)

129public string GetResponseHeaderValueWithCaching(HeaderDescriptor descriptor, ReadOnlySpan<byte> value, Encoding? valueEncoding) 136static string GetOrAddCachedValue([NotNull] ref string? cache, HeaderDescriptor descriptor, ReadOnlySpan<byte> value, Encoding? encoding) 188throw new HttpRequestException(HttpRequestError.InvalidResponse, SR.Format(SR.net_http_invalid_response_status_code, Encoding.ASCII.GetString(value)));

System\Net\Http\SocketsHttpHandler\SocketsHttpHandler.cs (2)

431/// Gets or sets a callback that returns the <see cref="Encoding"/> to encode the value for the specified request header name, 445/// Gets or sets a callback that returns the <see cref="Encoding"/> to decode the value for the specified response header name,

System\Net\Http\SocketsHttpHandler\SocksHelper.cs (2)

324return checked((byte)Encoding.UTF8.GetBytes(chars, buffer)); 328Debug.Assert(Encoding.UTF8.GetByteCount(chars) > 255);

System\Net\Http\StringContent.cs (4)

39public StringContent(string content, Encoding? encoding) 48public StringContent(string content, Encoding? encoding, string? mediaType) 80public StringContent(string content, Encoding? encoding, MediaTypeHeaderValue? mediaType) 90private static byte[] GetContentByteArray(string content, Encoding? encoding)

System.Net.Http.Json (17)

System\Net\Http\Json\HttpContentJsonExtensions.cs (3)

136return JsonHelpers.GetEncoding(content) is Encoding sourceEncoding && sourceEncoding != Encoding.UTF8 141private static async ValueTask<Stream> GetTranscodingStreamAsync(Task<Stream> task, Encoding sourceEncoding)

System\Net\Http\Json\HttpContentJsonExtensions.netcoreapp.cs (3)

18private static Stream GetTranscodingStream(Stream contentStream, Encoding sourceEncoding) 20return Encoding.CreateTranscodingStream(contentStream, innerStreamEncoding: sourceEncoding, outerStreamEncoding: Encoding.UTF8);

System\Net\Http\Json\JsonContent.cs (5)

115Encoding? targetEncoding = JsonHelpers.GetEncoding(this); 117return targetEncoding != null && targetEncoding != Encoding.UTF8 122private async Task SerializeToStreamAsyncTranscoding(Stream targetStream, bool async, Encoding targetEncoding, CancellationToken cancellationToken) 126Stream transcodingStream = Encoding.CreateTranscodingStream(targetStream, targetEncoding, Encoding.UTF8, leaveOpen: true);

System\Net\Http\Json\JsonContent.netcoreapp.cs (2)

16if (JsonHelpers.GetEncoding(this) is Encoding targetEncoding && targetEncoding != Encoding.UTF8)

System\Net\Http\Json\JsonHelpers.cs (4)

30internal static Encoding? GetEncoding(HttpContent content) 32Encoding? encoding = null; 41encoding = Encoding.GetEncoding(charset.Substring(1, charset.Length - 2)); 45encoding = Encoding.GetEncoding(charset);

System.Net.HttpListener (24)

src\libraries\Common\src\System\Net\WebSockets\WebSocketValidate.cs (2)

85Encoding.UTF8.GetMaxByteCount(statusDescription.Length) > MaxControlFramePayloadLength && 86Encoding.UTF8.GetByteCount(statusDescription) > MaxControlFramePayloadLength)

System\Net\HttpListenerRequest.cs (8)

70public Encoding ContentEncoding 81return Encoding.GetEncoding(postDataCharset); 97return Encoding.GetEncoding(charSet); 105return Encoding.Default; 410private static string UrlDecodeStringFromStringInternal(string s, Encoding e) 485private readonly Encoding _encoding; 496internal UrlDecoder(int bufferSize, Encoding encoding) 533internal static void FillFromString(NameValueCollection nvc, string s, bool urlencoded, Encoding encoding)

System\Net\HttpListenerRequestUriBuilder.cs (7)

19private static readonly Encoding s_ansiEncoding = Encoding.GetEncoding(0, new EncoderExceptionFallback(), new DecoderExceptionFallback()); 107Encoding secondaryEncoding = GetEncoding(EncodingType.Secondary); 120private static Encoding GetEncoding(EncodingType type) 134private ParsingResult BuildRequestUriUsingRawPath(Encoding encoding) 170private ParsingResult ParseRawPath(Encoding encoding) 294private bool EmptyDecodeAndAppendRawOctetsList(Encoding encoding)

System\Net\HttpListenerResponse.cs (1)

34public Encoding? ContentEncoding { get; set; }

System\Net\Managed\HttpConnection.cs (1)

458byte[] error = Encoding.Default.GetBytes(str);

System\Net\Managed\HttpListenerContext.Managed.cs (1)

69string authString = Encoding.UTF8.GetString(Convert.FromBase64String(headerValue));

System\Net\Managed\HttpListenerResponse.Managed.cs (2)

269Encoding encoding = Encoding.Default;

System\Net\Managed\HttpResponseStream.Managed.cs (1)

132Encoding.ASCII.GetBytes($"{size:x}\r\n{(final ? "\r\n" : "")}");

System\Net\WebSockets\HttpWebSocket.cs (1)

22byte[] toHash = Encoding.UTF8.GetBytes(acceptString);

System.Net.Mail (82)

System\Net\Base64Stream.cs (1)

142public int EncodeString(string value, Encoding encoding) => _encoder.EncodeString(value, encoding);

System\Net\BufferBuilder.cs (2)

70int byteCount = Encoding.UTF8.GetByteCount(value, offset, count); 72Encoding.UTF8.GetBytes(value, offset, count, _buffer, _offset);

System\Net\Mail\AlternateView.cs (1)

70public static AlternateView CreateAlternateViewFromString(string content, Encoding? contentEncoding, string? mediaType)

System\Net\Mail\Attachment.cs (13)

91Encoding encoding; 95encoding = Text.Encoding.GetEncoding(contentType.CharSet); 101encoding = Text.Encoding.ASCII; 105encoding = Text.Encoding.GetEncoding(MimeBasePart.DefaultCharSet); 121internal void SetContentFromString(string content, Encoding? encoding, string? mediaType) 157encoding = Encoding.ASCII; 161encoding = Encoding.GetEncoding(MimeBasePart.DefaultCharSet); 287private Encoding? _nameEncoding; 346Encoding encoding = NameEncoding ?? Encoding.GetEncoding(MimeBasePart.DefaultCharSet); 363Encoding? nameEncoding = MimeBasePart.DecodeEncoding(value); 380public Encoding? NameEncoding 421public static Attachment CreateAttachmentFromString(string content, string? name, Encoding? contentEncoding, string? mediaType)

System\Net\Mail\LinkedResource.cs (1)

59public static LinkedResource CreateLinkedResourceFromString(string content, Encoding? contentEncoding, string? mediaType)

System\Net\Mail\MailAddress.cs (13)

20private readonly Encoding _displayNameEncoding; 27internal MailAddress(string displayName, string userName, string domain, Encoding? displayNameEncoding) 32_displayNameEncoding = displayNameEncoding ?? Encoding.GetEncoding(MimeBasePart.DefaultCharSet); 44public MailAddress(string address) : this(address, null, (Encoding?)null) 48public MailAddress(string address, string? displayName) : this(address, displayName, (Encoding?)null) 65public MailAddress(string address, string? displayName, Encoding? displayNameEncoding) 68out (string displayName, string user, string host, Encoding displayNameEncoding) parsedData, 101/// <param name="displayNameEncoding">The <see cref="Encoding"/> that defines the character set used for displayName</param> 104public static bool TryCreate([NotNullWhen(true)] string? address, string? displayName, Encoding? displayNameEncoding, [NotNullWhen(true)] out MailAddress? result) 107out (string displayName, string user, string host, Encoding displayNameEncoding) parsed, 120private static bool TryParse([NotNullWhen(true)] string? address, string? displayName, Encoding? displayNameEncoding, out (string displayName, string user, string host, Encoding displayNameEncoding) parsedData, bool throwExceptionIfFail) 132displayNameEncoding ??= Encoding.GetEncoding(MimeBasePart.DefaultCharSet);

System\Net\Mail\MailMessage.cs (6)

29private Encoding? _bodyEncoding; 180public Encoding? SubjectEncoding 200public Encoding? HeadersEncoding 228_bodyEncoding = Text.Encoding.ASCII; 232_bodyEncoding = Text.Encoding.GetEncoding(MimeBasePart.DefaultCharSet); 238public Encoding? BodyEncoding

System\Net\Mail\MailPriority.cs (9)

33private Encoding? _subjectEncoding; 34private Encoding? _headersEncoding; 136Encoding? inputEncoding = null; 167_subjectEncoding = Encoding.GetEncoding(MimeBasePart.DefaultCharSet); 173internal Encoding? SubjectEncoding 199internal Encoding? HeadersEncoding 353_headersEncoding ??= Encoding.GetEncoding(MimeBasePart.DefaultCharSet); 384_headersEncoding ??= Encoding.GetEncoding(MimeBasePart.DefaultCharSet); 490_headersEncoding ??= Encoding.GetEncoding(MimeBasePart.DefaultCharSet);

System\Net\Mail\SmtpLoginAuthenticationModule.cs (2)

39return new Authorization(Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(userName)), false); 45return new Authorization(Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(cachedCredential.Password)), true);

System\Net\Mail\SmtpReplyReaderFactory.cs (2)

337builder.Append(Encoding.UTF8.GetString(_byteBuffer, start, actual)); 471_builder!.Append(Encoding.UTF8.GetString(_parent._byteBuffer!, start, actual));

System\Net\Mime\ByteEncoder.cs (3)

15public string GetEncodedString() => Encoding.ASCII.GetString(WriteState.Buffer, 0, WriteState.Length); 54public int EncodeString(string value, Encoding encoding) 61if (encoding == Encoding.Latin1) // we don't need to check for codepoints

System\Net\Mime\ContentDisposition.cs (2)

226Encoding? encoding = MimeBasePart.DecodeEncoding(value); 239encoding = Encoding.GetEncoding(MimeBasePart.DefaultCharSet);

System\Net\Mime\ContentType.cs (3)

119Encoding? nameEncoding = MimeBasePart.DecodeEncoding(value); 194Encoding? encoding = MimeBasePart.DecodeEncoding(value); 207encoding = Encoding.GetEncoding(MimeBasePart.DefaultCharSet);

System\Net\Mime\EightBitStream.cs (1)

129public int EncodeString(string value, Encoding encoding) { throw new NotImplementedException(); }

System\Net\Mime\EncodedStreamFactory.cs (3)

20internal static IEncodableStream GetEncoderForHeader(Encoding encoding, bool useBase64Encoding, int headerTextLength) 39private static byte[] CreateHeader(Encoding encoding, bool useBase64Encoding) => 40Encoding.ASCII.GetBytes("=?" + encoding.HeaderName + "?" + (useBase64Encoding ? "B?" : "Q?"));

System\Net\Mime\IByteEncoder.cs (1)

13int EncodeString(string value, Encoding encoding);

System\Net\Mime\IEncodableStream.cs (1)

13int EncodeString(string value, Encoding encoding);

System\Net\Mime\MimeBasePart.cs (14)

20internal static bool ShouldUseBase64Encoding(Encoding? encoding) => 21encoding == Encoding.Unicode || encoding == Encoding.UTF8 || encoding == Encoding.UTF32 || encoding == Encoding.BigEndianUnicode; 24internal static string EncodeHeaderValue(string value, Encoding encoding, bool base64Encoding) => 28internal static string EncodeHeaderValue(string value, Encoding? encoding, bool base64Encoding, int headerLength) 36encoding ??= Encoding.GetEncoding(DefaultCharSet); 74byte[] buffer = Encoding.ASCII.GetBytes(subStrings[3]); 77IEncodableStream s = EncodedStreamFactory.GetEncoderForHeader(Encoding.GetEncoding(charSet), base64Encoding, 0); 81Encoding encoding = Encoding.GetEncoding(charSet); 91internal static Encoding? DecodeEncoding(string? value) 107return Encoding.GetEncoding(value[subStrings[1]]);

System\Net\Mime\MimeWriter.cs (1)

25_boundaryBytes = Encoding.ASCII.GetBytes(boundary);

System\Net\Mime\QEncodedStream.cs (1)

185public int EncodeString(string value, Encoding encoding) => _encoder.EncodeString(value, encoding);

System\Net\Mime\QuotedPrintableStream.cs (2)

295public int EncodeString(string value, Encoding encoding) 301public string GetEncodedString() => Encoding.ASCII.GetString(WriteState.Buffer, 0, WriteState.Length);

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.Requests (5)

System\Net\CommandStream.cs (3)

469private Encoding _encoding = Encoding.UTF8; 472protected Encoding Encoding

System\Net\FtpControlStream.cs (2)

287Encoding = Encoding.UTF8; 291Encoding = Encoding.Default;

System.Net.Security (19)

src\libraries\Common\src\Microsoft\Win32\SafeHandles\GssSafeHandles.cs (3)

22out minorStatus, name, Encoding.UTF8.GetByteCount(name), out retHandle); 39out minorStatus, name, Encoding.UTF8.GetByteCount(name), out retHandle); 120status = Interop.NetSecurityNative.InitiateCredWithPassword(out minorStatus, packageType, userHandle, password, Encoding.UTF8.GetByteCount(password), out retHandle);

System\Net\NegotiateAuthenticationPal.ManagedNtlm.cs (9)

System\Net\NegotiateAuthenticationPal.Unix.cs (1)

540return Encoding.UTF8.GetString(tokenBytes);

System\Net\Security\CipherSuitesPolicyPal.Linux.cs (1)

197public OpenSslStringBuilder() : base(new MemoryStream(), Encoding.ASCII)

System\Net\Security\SslApplicationProtocol.cs (3)

12private static readonly Encoding s_utf8 = Encoding.GetEncoding(Encoding.UTF8.CodePage, EncoderFallback.ExceptionFallback, DecoderFallback.ExceptionFallback);

System\Net\Security\TlsFrameHelper.cs (2)

169private static readonly Encoding s_encoding = Encoding.GetEncoding("utf-8", new EncoderExceptionFallback(), new DecoderExceptionFallback());

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 (13)

System\Net\WebClient.cs (13)

33private Encoding _encoding = Encoding.Default; 142public Encoding Encoding 510formHeaderBytes = Encoding.UTF8.GetBytes(formHeader); 613byte[] buffer = Encoding.ASCII.GetBytes(values.ToString()); 1086private static readonly Encoding[] s_knownEncodings = { Encoding.UTF8, Encoding.UTF32, Encoding.Unicode, Encoding.BigEndianUnicode }; 1090Encoding? enc = null; 1120enc = Encoding.GetEncoding(item); 1138foreach (Encoding encoding in s_knownEncodings)

System.Net.WebHeaderCollection (1)

System\Net\WebHeaderCollection.cs (1)

417return System.Text.Encoding.ASCII.GetBytes(tempString);

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 (3)

src\libraries\Common\src\System\Net\WebSockets\WebSocketValidate.cs (2)

85Encoding.UTF8.GetMaxByteCount(statusDescription.Length) > MaxControlFramePayloadLength && 86Encoding.UTF8.GetByteCount(statusDescription) > MaxControlFramePayloadLength)

System\Net\WebSockets\WebSocketHandle.Managed.cs (1)

498int encodedSecKeyLength = Encoding.ASCII.GetBytes(secKey, bytes);

System.Private.CoreLib (289)

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)

38Debug.Assert(buffer.Length >= Encoding.UTF8.GetMaxCharCount(NameBufferSize - 1 - 1)); 49int charCount = Encoding.UTF8.GetChars(nameBytes, buffer);

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\CodeDom\Compiler\IndentedTextWriter.cs (1)

33public override Encoding Encoding => _writer.Encoding;

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventPipePayloadDecoder.cs (1)

129decodedFields[i] = BitConverter.IsLittleEndian ? new string(charPayload) : Encoding.Unicode.GetString(MemoryMarshal.Cast<char, byte>(charPayload));

src\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 (3)

458return (manifestBytes == null) ? null : Encoding.UTF8.GetString(manifestBytes, 0, manifestBytes.Length); 1765byte[] bytes = Encoding.BigEndianUnicode.GetBytes(name); 5628return (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)

373Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(amDesignatorUtf8 ??= Encoding.UTF8.GetBytes(AMDesignator)); 622Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(dateSeparatorUtf8 ??= Encoding.UTF8.GetBytes(DateSeparator)); 825Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(pmDesignatorUtf8 ??= Encoding.UTF8.GetBytes(PMDesignator)); 1007Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(timeSeparatorUtf8 ??= Encoding.UTF8.GetBytes(TimeSeparator)); 1707Unsafe.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 (4)

20private readonly Encoding _encoding; 31public BinaryReader(Stream input) : this(input, Encoding.UTF8, false) 35public BinaryReader(Stream input, Encoding encoding) : this(input, encoding, false) 39public BinaryReader(Stream input, Encoding encoding, bool leaveOpen)

src\libraries\System.Private.CoreLib\src\System\IO\BinaryWriter.cs (5)

23private readonly Encoding _encoding; 32_encoding = Encoding.UTF8; 37public BinaryWriter(Stream output) : this(output, Encoding.UTF8, false) 41public BinaryWriter(Stream output, Encoding encoding) : this(output, encoding, false) 45public BinaryWriter(Stream output, Encoding encoding, bool leaveOpen)

src\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\EncodingCache.cs (1)

10internal static readonly Encoding UTF8NoBOM = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);

src\libraries\System.Private.CoreLib\src\System\IO\File.cs (37)

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\ReadLinesIterator.cs (4)

31private readonly Encoding _encoding; 34private ReadLinesIterator(string path, Encoding encoding, StreamReader reader) 89internal static ReadLinesIterator CreateIterator(string path, Encoding encoding) 94private static ReadLinesIterator CreateIterator(string path, Encoding encoding, StreamReader? reader)

src\libraries\System.Private.CoreLib\src\System\IO\StreamReader.cs (20)

32private Encoding _encoding = null!; // only null in NullStreamReader where this is never used 110: this(stream, Encoding.UTF8, detectEncodingFromByteOrderMarks, DefaultBufferSize, false) 114public StreamReader(Stream stream, Encoding? encoding) 119public StreamReader(Stream stream, Encoding? encoding, bool detectEncodingFromByteOrderMarks) 134public StreamReader(Stream stream, Encoding? encoding, bool detectEncodingFromByteOrderMarks, int bufferSize) 139public StreamReader(Stream stream, Encoding? encoding = null, bool detectEncodingFromByteOrderMarks = true, int bufferSize = -1, bool leaveOpen = false) 158_encoding = encoding ??= Encoding.UTF8; 186: this(path, Encoding.UTF8, detectEncodingFromByteOrderMarks, DefaultBufferSize) 190public StreamReader(string path, Encoding? encoding) 195public StreamReader(string path, Encoding? encoding, bool detectEncodingFromByteOrderMarks) 200public StreamReader(string path, Encoding? encoding, bool detectEncodingFromByteOrderMarks, int bufferSize) 206: this(path, Encoding.UTF8, true, options) 210public StreamReader(string path, Encoding? encoding, bool detectEncodingFromByteOrderMarks, FileStreamOptions options) 269public virtual Encoding CurrentEncoding => _encoding; 480_encoding = Encoding.BigEndianUnicode; 489_encoding = Encoding.Unicode; 495_encoding = Encoding.UTF32; 503_encoding = Encoding.UTF8; 1412public override Encoding CurrentEncoding => Encoding.Unicode;

src\libraries\System.Private.CoreLib\src\System\IO\StreamWriter.cs (9)

34private readonly Encoding _encoding; 73private static Encoding UTF8NoBOM => EncodingCache.UTF8NoBOM; 80public StreamWriter(Stream stream, Encoding? encoding) 89public StreamWriter(Stream stream, Encoding? encoding, int bufferSize) 94public StreamWriter(Stream stream, Encoding? encoding = null, int bufferSize = -1, bool leaveOpen = false) 143public StreamWriter(string path, bool append, Encoding? encoding) 148public StreamWriter(string path, bool append, Encoding? encoding, int bufferSize) : 158public StreamWriter(string path, Encoding? encoding, FileStreamOptions options) 344public override Encoding Encoding => _encoding;

src\libraries\System.Private.CoreLib\src\System\IO\StringWriter.cs (1)

60public override Encoding Encoding => s_encoding ??= new UnicodeEncoding(false, false);

src\libraries\System.Private.CoreLib\src\System\IO\TextWriter.CreateBroadcasting.cs (1)

58public override Encoding Encoding => _writers[0].Encoding;

src\libraries\System.Private.CoreLib\src\System\IO\TextWriter.cs (4)

90public abstract Encoding Encoding 694public override Encoding Encoding => Encoding.Unicode; 778public override Encoding Encoding => _out.Encoding;

src\libraries\System.Private.CoreLib\src\System\Net\WebUtility.cs (6)

345int byteCount = Encoding.UTF8.GetByteCount(value); 351Encoding.UTF8.GetBytes(state.value, utf8Bytes); 447private static string? UrlDecodeInternal(string? value, Encoding encoding) 560return UrlDecodeInternal(encodedValue, Encoding.UTF8); 618private readonly Encoding _encoding; 629internal UrlDecoder(int bufferSize, Encoding encoding)

src\libraries\System.Private.CoreLib\src\System\Number.Formatting.cs (1)

628return 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)

39_store = new BinaryReader(stream, Encoding.UTF8);

src\libraries\System.Private.CoreLib\src\System\Resources\ResourceReader.cs (3)

101_store = new BinaryReader(new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read, DefaultFileStreamBufferSize, FileOptions.RandomAccess), Encoding.UTF8); 133_store = new BinaryReader(stream, Encoding.UTF8); 443return Encoding.Unicode.GetString(bytes, 0, byteLen);

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); 970int nb = Encoding.UTF8.GetMaxByteCount(s.Length); 975int nbWritten = Encoding.UTF8.GetBytes(s, new Span<byte>(pbMem, nb)); 1011int nb = Encoding.UTF8.GetMaxByteCount(s.Length); 1016int 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 (4)

247return CreateStringFromEncoding(pb, numBytes, Encoding.UTF8); 256public extern unsafe String(sbyte* value, int startIndex, int length, Encoding enc); 258private static unsafe string Ctor(sbyte* value, int startIndex, int length, Encoding? enc) 534byte* bytes, int byteLength, Encoding encoding)

src\libraries\System.Private.CoreLib\src\System\Text\DecoderFallback.cs (3)

64internal Encoding? _encoding; 83internal static DecoderFallbackBuffer CreateAndInitialize(Encoding encoding, DecoderNLS? decoder, int originalByteCount) 260Encoding.ThrowConversionOverflow();

src\libraries\System.Private.CoreLib\src\System\Text\DecoderNLS.cs (2)

24private readonly Encoding _encoding; 31internal DecoderNLS(Encoding encoding)

src\libraries\System.Private.CoreLib\src\System\Text\EncoderFallback.cs (3)

72private Encoding? encoding; 98internal static EncoderFallbackBuffer CreateAndInitialize(Encoding encoding, EncoderNLS? encoder, int originalCharCount) 270Encoding.ThrowConversionOverflow();

src\libraries\System.Private.CoreLib\src\System\Text\EncoderNLS.cs (4)

26private readonly Encoding _encoding; 31internal EncoderNLS(Encoding encoding) 209public Encoding Encoding 221/// States whether a call to <see cref="Encoding.GetBytes(char*, int, byte*, int, EncoderNLS)"/> must first drain data on this <see cref="EncoderNLS"/> instance.

src\libraries\System.Private.CoreLib\src\System\Text\Encoding.cs (40)

src\libraries\System.Private.CoreLib\src\System\Text\Encoding.Internal.cs (2)

95/// Given a <see cref="Rune"/>, determines its byte count under the current <see cref="Encoding"/>. 97/// current <see cref="Encoding"/>.

src\libraries\System.Private.CoreLib\src\System\Text\EncodingData.cs (4)

241private const uint MIMECONTF_MAILNEWS = Encoding.MIMECONTF_MAILNEWS; 242private const uint MIMECONTF_BROWSER = Encoding.MIMECONTF_BROWSER; 243private const uint MIMECONTF_SAVABLE_MAILNEWS = Encoding.MIMECONTF_SAVABLE_MAILNEWS; 244private const uint MIMECONTF_SAVABLE_BROWSER = Encoding.MIMECONTF_SAVABLE_BROWSER;

src\libraries\System.Private.CoreLib\src\System\Text\EncodingInfo.cs (4)

53/// Get the <see cref="Encoding"/> object match the information in the <see cref="EncodingInfo"/> object 55/// <returns>The <see cref="Encoding"/> object</returns> 56public Encoding GetEncoding() => Provider?.GetEncoding(CodePage) ?? Encoding.GetEncoding(CodePage);

src\libraries\System.Private.CoreLib\src\System\Text\EncodingProvider.cs (16)

src\libraries\System.Private.CoreLib\src\System\Text\EncodingTable.cs (3)

119if (codePage == Encoding.CodePageUTF7 && !LocalAppContextSwitches.EnableUnsafeUTF7Encoding) 151if (codePage != Encoding.CodePageUTF7 || LocalAppContextSwitches.EnableUnsafeUTF7Encoding) 163encodingInfoList.Remove(Encoding.CodePageUTF7); // won't throw if doesn't exist

src\libraries\System.Private.CoreLib\src\System\Text\Latin1Encoding.Sealed.cs (1)

11/// off of <see cref="Encoding.Latin1"/>.

src\libraries\System.Private.CoreLib\src\System\Text\TranscodingStream.cs (4)

28private readonly Encoding _innerEncoding; 29private readonly Encoding _thisEncoding; 53internal TranscodingStream(Stream innerStream, Encoding innerEncoding, Encoding thisEncoding, bool leaveOpen)

src\libraries\System.Private.CoreLib\src\System\Text\Unicode\Utf8.cs (1)

564if (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 (2)

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)

342int cUtf8Name = Encoding.UTF8.GetByteCount(name); 358Encoding.UTF8.GetBytes(name, utf8Name); 4351=> Encoding.UTF8.GetString(new ReadOnlySpan<byte>(m_pStringHeap, m_StringHeapByteLength));

src\System\String.CoreCLR.cs (1)

60internal unsafe int GetBytesFromEncoding(byte* pbNativeBuffer, int cbNativeBuffer, Encoding encoding)

src\System\StubHelpers.cs (4)

46string str = Encoding.Default.GetString(bytes); 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);

EventSourceGenerator.Parser.cs (1)

107byte[] bytes = Encoding.BigEndianUnicode.GetBytes(name);

System.Private.DataContractSerialization (95)

System\Runtime\Serialization\DataContract.cs (1)

1722byte[] namespaceBytes = Encoding.UTF8.GetBytes(namespaces);

System\Runtime\Serialization\Json\DataContractJsonSerializer.cs (1)

294XmlDictionaryWriter jsonWriter = JsonReaderWriterFactory.CreateJsonWriter(stream, Encoding.UTF8, false); // ownsStream

System\Runtime\Serialization\Json\IXmlJsonReaderInitializer.cs (2)

13void SetInput(byte[] buffer, int offset, int count, Encoding? encoding, XmlDictionaryReaderQuotas quotas, 16void SetInput(Stream stream, Encoding? encoding, XmlDictionaryReaderQuotas quotas,

System\Runtime\Serialization\Json\IXmlJsonWriterInitializer.cs (1)

12void SetOutput(Stream stream, Encoding encoding, bool ownsStream);

System\Runtime\Serialization\Json\JsonEncodingStreamWrapper.cs (8)

25private Encoding? _encoding; 32public JsonEncodingStreamWrapper(Stream stream, Encoding? encoding, bool isReader) 124public static ArraySegment<byte> ProcessBuffer(byte[] buffer, int offset, int count, Encoding? encoding) 202_byteCount = Encoding.UTF8.GetBytes(_chars, 0, charCount, _bytes, 0); 285private static Encoding GetEncoding(SupportedEncoding e) => 303private static SupportedEncoding GetSupportedEncoding(Encoding? encoding) 429private void InitForReading(Stream inputStream, Encoding? expectedEncoding) 462private void InitForWriting(Stream outputStream, Encoding writeEncoding)

System\Runtime\Serialization\Json\JsonReaderWriterFactory.cs (7)

29public static XmlDictionaryReader CreateJsonReader(Stream stream, Encoding? encoding, XmlDictionaryReaderQuotas quotas, OnXmlDictionaryReaderClose? onClose) 41public static XmlDictionaryReader CreateJsonReader(byte[] buffer, int offset, int count, Encoding? encoding, XmlDictionaryReaderQuotas quotas, OnXmlDictionaryReaderClose? onClose) 50return CreateJsonWriter(stream, Encoding.UTF8, true); 53public static XmlDictionaryWriter CreateJsonWriter(Stream stream, Encoding encoding) 58public static XmlDictionaryWriter CreateJsonWriter(Stream stream, Encoding encoding, bool ownsStream) 63public static XmlDictionaryWriter CreateJsonWriter(Stream stream, Encoding encoding, bool ownsStream, bool indent) 68public static XmlDictionaryWriter CreateJsonWriter(Stream stream, Encoding encoding, bool ownsStream, bool indent, string? indentChars)

System\Runtime\Serialization\Json\JsonXmlDataContract.cs (1)

33MemoryStream memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(xmlContent));

System\Runtime\Serialization\Json\XmlJsonReader.cs (10)

System\Runtime\Serialization\Json\XmlJsonWriter.cs (2)

236public void SetOutput(Stream stream, Encoding encoding, bool ownsStream) 241if (encoding.WebName != Encoding.UTF8.WebName)

System\Runtime\Serialization\XmlObjectSerializer.cs (1)

37XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(stream, Encoding.UTF8, false /*ownsStream*/);

System\Xml\EncodingStreamWrapper.cs (9)

40private Encoding? _encoding; 54public EncodingStreamWrapper(Stream stream, Encoding? encoding) 123private static Encoding GetEncoding(SupportedEncoding e) => 132private static Encoding GetSafeEncoding(SupportedEncoding e) => 150private static SupportedEncoding GetSupportedEncoding(Encoding? encoding) 165public EncodingStreamWrapper(Stream stream, Encoding encoding, bool emitBOM) 432internal static ArraySegment<byte> ProcessBuffer(byte[] buffer, int offset, int count, Encoding? encoding) 453Encoding localEnc; 612_byteCount = Encoding.UTF8.GetBytes(_chars, 0, charCount, _bytes, 0);

System\Xml\XmlBaseReader.cs (1)

1418private int ReadBytes(Encoding encoding, int byteBlock, int charBlock, byte[] buffer, int offset, int byteCount, bool readContent)

System\Xml\XmlBaseWriter.cs (1)

1644_textFragmentWriter.SetOutput(stream, false, Encoding.UTF8);

System\Xml\XmlCanonicalWriter.cs (7)

184_element.prefixLength = Encoding.UTF8.GetByteCount(prefix); 186_element.localNameLength = Encoding.UTF8.GetByteCount(localName); 254if (string.Equals(Encoding.UTF8.GetString(_xmlnsBuffer!, xmlnsAttribute.prefixOffset, xmlnsAttribute.prefixLength), _inclusivePrefixes[i], StringComparison.Ordinal)) 371xmlnsAttribute.prefixLength = Encoding.UTF8.GetBytes(prefix, 0, prefix.Length, _xmlnsBuffer, _xmlnsOffset); 374xmlnsAttribute.nsLength = Encoding.UTF8.GetBytes(ns, 0, ns.Length, _xmlnsBuffer, _xmlnsOffset); 424_attribute.prefixLength = Encoding.UTF8.GetByteCount(prefix); 426_attribute.localNameLength = Encoding.UTF8.GetByteCount(localName);

System\Xml\XmlDictionaryAsyncCheckWriter.cs (1)

700public void SetOutput(Stream stream, Encoding encoding, bool ownsStream)

System\Xml\XmlDictionaryReader.cs (12)

System\Xml\XmlDictionaryString.cs (1)

78return _buffer ??= System.Text.Encoding.UTF8.GetBytes(_value);

System\Xml\XmlDictionaryWriter.cs (4)

47public static XmlDictionaryWriter CreateTextWriter(Stream stream, Encoding encoding) 52public static XmlDictionaryWriter CreateTextWriter(Stream stream, Encoding encoding, bool ownsStream) 60public static XmlDictionaryWriter CreateMtomWriter(Stream stream, Encoding encoding, int maxSizeInBytes, string startInfo) 65public static XmlDictionaryWriter CreateMtomWriter(Stream stream, Encoding encoding, int maxSizeInBytes, string startInfo, string? boundary, string? startUri, bool writeMessageHeaders, bool ownsStream)

System\Xml\XmlNodeWriter.cs (8)

System\Xml\XmlStreamNodeWriter.cs (2)

22private Encoding? _encoding; 30protected void SetOutput(Stream stream, bool ownsStream, Encoding? encoding)

System\Xml\XmlUTF8TextReader.cs (6)

20void SetInput(byte[] buffer, int offset, int count, Encoding? encoding, XmlDictionaryReaderQuotas quotas, OnXmlDictionaryReaderClose? onClose); 21void SetInput(Stream stream, Encoding? encoding, XmlDictionaryReaderQuotas quotas, OnXmlDictionaryReaderClose? onClose); 556public void SetInput(byte[] buffer, int offset, int count, Encoding? encoding, XmlDictionaryReaderQuotas quotas, OnXmlDictionaryReaderClose? onClose) 572public void SetInput(Stream stream, Encoding? encoding, XmlDictionaryReaderQuotas quotas, OnXmlDictionaryReaderClose? onClose) 646XmlExceptionHelper.ThrowTokenExpected(this, "?>", Encoding.UTF8.GetString(buffer, offset, 2)); 1056XmlExceptionHelper.ThrowTokenExpected(this, "[CDATA[", Encoding.UTF8.GetString(buffer, offset, 7));

System\Xml\XmlUTF8TextWriter.cs (9)

13void SetOutput(Stream stream, Encoding encoding, bool ownsStream); 20public void SetOutput(Stream stream, Encoding encoding, bool ownsStream) 25if (encoding.WebName != Encoding.UTF8.WebName) 58private Encoding? _encoding; 90public new void SetOutput(Stream stream, bool ownsStream, Encoding? encoding) 92Encoding? utf8Encoding = null; 93if (encoding != null && encoding.CodePage == Encoding.UTF8.CodePage) 103public Encoding? Encoding 131if (_encoding.WebName == Encoding.BigEndianUnicode.WebName)

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 (84)

System\Xml\BinaryXml\XmlBinaryReader.cs (6)

3981Encoding enc = System.Text.Encoding.GetEncoding(codepage); 4128Encoding enc = System.Text.Encoding.GetEncoding(codepage); 4305Encoding enc = System.Text.Encoding.GetEncoding(codepage);

System\Xml\Core\XmlEncodedRawTextWriter.cs (2)

33protected Encoding? _encoding; 163_encoding = (Encoding)settings.Encoding.Clone();

System\Xml\Core\XmlParserContext.cs (4)

23private Encoding? _encoding; 31public XmlParserContext(XmlNameTable? nt, XmlNamespaceManager? nsMgr, string? xmlLang, XmlSpace xmlSpace, Encoding? enc) 47string? xmlLang, XmlSpace xmlSpace, Encoding? enc) 195public Encoding? Encoding

System\Xml\Core\XmlTextReader.cs (1)

377public Encoding? Encoding

System\Xml\Core\XmlTextReaderImpl.cs (31)

214private Encoding? _reportedEncoding; 508Encoding? enc = context?.Encoding; 535InitStringInput(string.Empty, Encoding.Unicode, xmlFragment); 540InitStringInput(context.BaseURI, Encoding.Unicode, xmlFragment); 555InitStringInput((context == null) ? string.Empty : context.BaseURI, Encoding.Unicode, $"<?xml {xmlFragment}?>"); 651Encoding? enc = null; 728Encoding? enc = null; 813InitStringInput(string.Empty, Encoding.Unicode, xmlFragment); 2028internal Encoding? Encoding 2620InitStringInput(baseUri, Encoding.Unicode, internalDtd); 2818private void InitStreamInput(Stream stream, Encoding? encoding) 2823private void InitStreamInput(string baseUriStr, Stream stream, Encoding? encoding) 2829private void InitStreamInput(Uri? baseUri, Stream stream, Encoding? encoding) 2835private void InitStreamInput(Uri? baseUri, string baseUriStr, Stream stream, Encoding? encoding) 2840private void InitStreamInput(Uri? baseUri, string baseUriStr, Stream stream, byte[]? bytes, int byteCount, Encoding? encoding) 2936_ps.encoding = Encoding.Unicode; 2944private void InitStringInput(string baseUriStr, Encoding? originalEncoding, string str) 3087private Encoding? DetectEncoding() 3123return Encoding.BigEndianUnicode; 3132return Encoding.Unicode; 3141return Encoding.Unicode; 3150return Encoding.BigEndianUnicode; 3172private void SetupEncoding(Encoding? encoding) 3177_ps.encoding = Encoding.UTF8; 3204private void SwitchEncoding(Encoding newEncoding) 3219private Encoding CheckEncoding(string newEncodingName) 3250Encoding? newEncoding = null; 3259newEncoding = Encoding.GetEncoding(newEncodingName); 3614Encoding? encoding = null; 8018Encoding? enc = _ps.encoding; 8035Encoding? enc = _ps.encoding;

System\Xml\Core\XmlTextReaderImplAsync.cs (8)

84Encoding? enc = null; 116Encoding? enc = null; 860private Task InitStreamInputAsync(Uri baseUri, Stream stream, Encoding? encoding) 866private async Task InitStreamInputAsync(Uri? baseUri, string baseUriStr, Stream stream, byte[]? bytes, int byteCount, Encoding? encoding) 967_ps.encoding = Encoding.Unicode; 999private Task SwitchEncodingAsync(Encoding newEncoding) 1198Encoding? encoding = null; 5225Encoding? enc = _ps.encoding;

System\Xml\Core\XmlTextReaderImplHelpers.cs (1)

30internal Encoding? encoding;

System\Xml\Core\XmlTextWriter.cs (3)

135private readonly Encoding? _encoding; 280public XmlTextWriter(Stream w, Encoding? encoding) : this() 292public XmlTextWriter(string filename, Encoding? encoding)

System\Xml\Core\XmlUtf8RawTextWriter.cs (1)

35protected Encoding _encoding = null!;

System\Xml\Core\XmlValidatingReader.cs (1)

333public Encoding? Encoding

System\Xml\Core\XmlValidatingReaderImpl.cs (1)

440internal Encoding? Encoding

System\Xml\Core\XmlWriterSettings.cs (6)

45private Encoding _encoding; 78public Encoding Encoding 367Debug.Assert(Encoding.UTF8.WebName == "utf-8"); 503_encoding = Encoding.UTF8; 603Debug.Assert(Encoding.Equals(Encoding.GetEncoding(Encoding.CodePage)), "Cannot serialize encoding correctly"); 654Encoding = Encoding.GetEncoding(reader.ReadInt32());

System\Xml\Dom\XmlDocument.cs (2)

1350internal Encoding? TextEncoding 1359return System.Text.Encoding.GetEncoding(value);

System\Xml\Dom\XmlDomTextWriter.cs (2)

14public XmlDOMTextWriter(Stream w, Encoding? encoding) : base(w, encoding) 18public XmlDOMTextWriter(string filename, Encoding? encoding) : base(filename, encoding)

System\Xml\Resolvers\XmlPreloadedResolver.cs (1)

106return new MemoryStream(Encoding.Unicode.GetBytes(_str));

System\Xml\Serialization\Compiler.cs (1)

94byte[] valueBytes = Encoding.UTF8.GetBytes(value);

System\Xml\XmlEncoding.cs (4)

285internal static Encoding UCS4_Littleendian 293internal static Encoding UCS4_Bigendian 301internal static Encoding UCS4_2143 309internal static Encoding UCS4_3412

System\Xml\Xsl\Xslt\XsltLoader.cs (2)

663Encoding encoding = Encoding.GetEncoding(_input.Value);

System\Xml\Xsl\XsltOld\SequentialOutput.cs (3)

58protected Encoding? encoding; 75private Encoding? _utf8Encoding; 609_utf8Encoding = Encoding.UTF8;

System\Xml\Xsl\XsltOld\XsltOutput.cs (4)

26private Encoding _encoding = System.Text.Encoding.UTF8; 84internal Encoding Encoding 142_encoding = System.Text.Encoding.GetEncoding(value);

System.Private.Xml.Linq (4)

System\Xml\Linq\XDocument.cs (4)

8using Encoding = System.Text.Encoding; 596ws.Encoding = Encoding.GetEncoding(_declaration.Encoding); 629ws.Encoding = Encoding.GetEncoding(_declaration.Encoding); 773ws.Encoding = Encoding.GetEncoding(_declaration.Encoding);

System.Reflection.Emit (1)

System\Reflection\Emit\CustomAttributeWrapper.cs (1)

97return Text.Encoding.UTF8.GetString(data.Slice(pos, len));

System.Reflection.Metadata (8)

System\Reflection\Internal\Utilities\MemoryBlock.cs (2)

275return Encoding.Unicode.GetString(ptr, byteCount); 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 (3)

29public Encoding Encoding { get; } 35public static MetadataStringDecoder DefaultUTF8 { get; } = new MetadataStringDecoder(Encoding.UTF8); 44public MetadataStringDecoder(Encoding encoding)

System\Reflection\PortableExecutable\PEBinaryReader.cs (2)

32_reader = new BinaryReader(stream, Encoding.UTF8, leaveOpen: true); 107return Encoding.UTF8.GetString(bytes, 0, nonPaddedLength);

System.Reflection.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 (6)

src\libraries\Common\src\System\Resources\ResourceWriter.cs (3)

248BinaryWriter bw = new BinaryWriter(_output, Encoding.UTF8); 297BinaryWriter names = new BinaryWriter(nameSection, Encoding.Unicode); 303BinaryWriter data = new BinaryWriter(dataSection, Encoding.UTF8);

src\libraries\System.Private.CoreLib\src\System\Resources\ResourceReader.cs (3)

System.Resources.Writer (3)

src\libraries\Common\src\System\Resources\ResourceWriter.cs (3)

System.Runtime (1)

artifacts\obj\System.Runtime\Debug\net10.0\System.Runtime.Forwards.cs (1)

795[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Text.Encoding))]

System.Security.Cryptography (23)

src\libraries\Common\src\Internal\Cryptography\PkcsHelpers.cs (2)

144Encoding.Unicode.GetBytes(s, 0, s.Length, octets, 0); 166string s = Encoding.Unicode.GetString(octets, 0, end);

src\libraries\Common\src\Interop\Unix\System.Native\Interop.ReadLink.cs (1)

57return Encoding.UTF8.GetString(spanBuffer.Slice(0, resultLength));

src\libraries\Common\src\System\Security\Cryptography\PasswordBasedEncryption.cs (6)

174System.Text.Encoding? encoding = null; 182encoding = System.Text.Encoding.UTF8; 329System.Text.Encoding encoding = System.Text.Encoding.UTF8; 459System.Text.Encoding? encoding = null; 467encoding = System.Text.Encoding.UTF8;

src\libraries\Common\src\System\Security\Cryptography\Pkcs12Kdf.cs (2)

272Encoding bigEndianUnicode = System.Text.Encoding.BigEndianUnicode;

src\libraries\Common\src\System\Security\Cryptography\Utf8DataEncoding.cs (1)

10internal static Encoding ThrowingUtf8Encoding { get; } = new UTF8Encoding(false, true);

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\Rfc2898DeriveBytes.OneShot.cs (3)

156/// other encodings, convert the password string to bytes using the appropriate <see cref="System.Text.Encoding" /> 199/// other encodings, convert the password string to bytes using the appropriate <see cref="System.Text.Encoding" /> 244/// other encodings, convert the password string to bytes using the appropriate <see cref="System.Text.Encoding" />

System\Security\Cryptography\X509Certificates\OpenSslX509CertificateReader.cs (3)

815return Encoding.UTF8.GetString(buffer.Slice(0, total)); 885Span<char> dateString = stackalloc char[Encoding.ASCII.GetCharCount(bytes)]; 886Encoding.ASCII.GetChars(bytes, dateString);

System.Security.Cryptography.Pkcs (10)

src\libraries\Common\src\Internal\Cryptography\PkcsHelpers.cs (2)

144Encoding.Unicode.GetBytes(s, 0, s.Length, octets, 0); 166string s = Encoding.Unicode.GetString(octets, 0, end);

src\libraries\Common\src\System\Security\Cryptography\PasswordBasedEncryption.cs (6)

src\libraries\Common\src\System\Security\Cryptography\Pkcs12Kdf.cs (2)

272Encoding bigEndianUnicode = System.Text.Encoding.BigEndianUnicode;

System.Security.Cryptography.Xml (18)

System\Security\Cryptography\Xml\CanonicalXml.cs (1)

102return Encoding.UTF8.GetBytes(sb.ToString());

System\Security\Cryptography\Xml\CanonicalXmlAttribute.cs (2)

35byte[] rgbData = Encoding.UTF8.GetBytes(" " + Name + "=\""); 37rgbData = Encoding.UTF8.GetBytes(Utils.EscapeAttributeValue(Value));

System\Security\Cryptography\Xml\CanonicalXmlCDataSection.cs (1)

34byte[] rgbData = Encoding.UTF8.GetBytes(Utils.EscapeCData(Data));

System\Security\Cryptography\Xml\CanonicalXmlComment.cs (1)

61rgbData = Encoding.UTF8.GetBytes(Value!);

System\Security\Cryptography\Xml\CanonicalXmlElement.cs (2)

139rgbData = Encoding.UTF8.GetBytes("<" + Name); 167rgbData = Encoding.UTF8.GetBytes("</" + Name + ">");

System\Security\Cryptography\Xml\CanonicalXmlProcessingInstruction.cs (2)

57rgbData = Encoding.UTF8.GetBytes(Name); 62rgbData = Encoding.UTF8.GetBytes(" " + Value);

System\Security\Cryptography\Xml\CanonicalXmlSignificantWhitespace.cs (1)

36byte[] rgbData = Encoding.UTF8.GetBytes(Utils.EscapeWhitespaceData(Value));

System\Security\Cryptography\Xml\CanonicalXmlText.cs (1)

36byte[] rgbData = Encoding.UTF8.GetBytes(Utils.EscapeTextData(Value));

System\Security\Cryptography\Xml\CanonicalXmlWhitespace.cs (1)

36byte[] rgbData = Encoding.UTF8.GetBytes(Utils.EscapeWhitespaceData(Value));

System\Security\Cryptography\Xml\EncryptedXml.cs (3)

71private Encoding _encoding; 99_encoding = Encoding.UTF8; 164public Encoding Encoding

System\Security\Cryptography\Xml\ExcCanonicalXml.cs (1)

55return Encoding.UTF8.GetBytes(sb.ToString());

System\Security\Cryptography\Xml\SignedXmlDebugLog.cs (1)

605Encoding.UTF8.GetString(ms.ToArray()));

System\Security\Cryptography\Xml\XmlDsigBase64Transform.cs (1)

101byte[] buffer = Encoding.UTF8.GetBytes(sb.ToString());

System.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.Tests (21)

ServiceModel\BasicHttpBindingTest.cs (12)

26Assert.Equal<Encoding>(Encoding.GetEncoding("utf-8"), binding.TextEncoding); 27Assert.Equal(Encoding.GetEncoding("utf-8").WebName, binding.TextEncoding.WebName); 51Assert.Equal<Encoding>(Encoding.GetEncoding("utf-8"), binding.TextEncoding); 52Assert.Equal(Encoding.GetEncoding("utf-8").WebName, binding.TextEncoding.WebName); 75Assert.Equal<Encoding>(Encoding.GetEncoding("utf-8"), binding.TextEncoding); 76Assert.Equal(Encoding.GetEncoding("utf-8").WebName, binding.TextEncoding.WebName); 290public static void TextEncoding_Property_Sets(Encoding encoding) 294Assert.Equal<Encoding>(encoding, binding.TextEncoding); 299public static void TextEncoding_Property_Set_Invalid_Value_Throws(Encoding encoding)

ServiceModel\BasicHttpsBindingTest.cs (9)

24Assert.Equal<Encoding>(Encoding.GetEncoding("utf-8"), binding.TextEncoding); 25Assert.Equal(Encoding.GetEncoding("utf-8").WebName, binding.TextEncoding.WebName); 49Assert.Equal<Encoding>(Encoding.GetEncoding("utf-8"), binding.TextEncoding); 50Assert.Equal(Encoding.GetEncoding("utf-8").WebName, binding.TextEncoding.WebName); 280public static void TextEncoding_Property_Sets(Encoding encoding) 284Assert.Equal<Encoding>(encoding, binding.TextEncoding); 289public static void TextEncoding_Property_Set_Invalid_Value_Throws(Encoding encoding)

System.ServiceModel.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.Tests (6)

Channels\TextMessageEncodingBindingElementTest.cs (5)

20Assert.Equal<Encoding>(Encoding.UTF8, element.WriteEncoding); 25public static void WriteEncoding_Property_Sets(Encoding encoding) 29Assert.Equal<Encoding>(encoding, element.WriteEncoding); 34public static void WriteEncoding_Property_Set_Throws_For_Invalid_Encodings(Encoding encoding)

ServiceModel\ChannelFactoryTest.cs (1)

28new TextMessageEncodingBindingElement(MessageVersion.Default, Encoding.UTF8),

System.Text.Encoding (1)

System.Text.Encoding.cs (1)

16[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Text.Encoding))]

System.Text.Encoding.CodePages (9)

System\Text\CodePagesEncodingProvider.cs (8)

14private readonly Dictionary<int, Encoding> _encodings = new Dictionary<int, Encoding>(); 24public override Encoding? GetEncoding(int codepage) 39Encoding? result = null; 67if (_encodings.TryGetValue(codepage, out Encoding? cachedEncoding)) 85public override Encoding? GetEncoding(string name) 133private static Encoding? GetEncodingRare(int codepage) 135Encoding? result = null;

System\Text\EncoderNLS.cs (1)

210public Encoding Encoding

System.Text.Json (4)

System\Text\Json\JsonHelpers.cs (2)

200return Encoding.UTF8.GetString(bytes); 234int 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)

1637byte[] utf8Json = Encoding.UTF8.GetBytes(effectiveJsonPropertyName);

src\libraries\Common\src\SourceGenerators\SourceWriter.cs (1)

67return SourceText.From(_sb.ToString(), Encoding.UTF8);

System.Web.HttpUtility (25)

System\Web\HttpUtility.cs (17)

81public static NameValueCollection ParseQueryString(string query) => ParseQueryString(query, Encoding.UTF8); 83public static NameValueCollection ParseQueryString(string query, Encoding encoding) 161public static string? UrlEncode(string? str) => UrlEncode(str, Encoding.UTF8); 167public static string? UrlEncode(string? str, Encoding e) => 168str == null ? null : Encoding.ASCII.GetString(UrlEncodeToBytes(str, e)); 171public static string? UrlEncode(byte[]? bytes) => bytes == null ? null : Encoding.ASCII.GetString(UrlEncodeToBytes(bytes)); 174public static string? UrlEncode(byte[]? bytes, int offset, int count) => bytes == null ? null : Encoding.ASCII.GetString(UrlEncodeToBytes(bytes, offset, count)); 177public static byte[]? UrlEncodeToBytes(string? str) => UrlEncodeToBytes(str, Encoding.UTF8); 184public static byte[]? UrlEncodeUnicodeToBytes(string? str) => str == null ? null : Encoding.ASCII.GetBytes(UrlEncodeUnicode(str)); 187public static string? UrlDecode(string? str) => UrlDecode(str, Encoding.UTF8); 190public static string? UrlDecode(byte[]? bytes, Encoding e) => bytes == null ? null : UrlDecode(bytes, 0, bytes.Length, e); 193public static byte[]? UrlDecodeToBytes(string? str) => UrlDecodeToBytes(str, Encoding.UTF8); 196public static byte[]? UrlDecodeToBytes(string? str, Encoding e) 219public static byte[]? UrlEncodeToBytes(string? str, Encoding e) => str == null ? null : HttpEncoder.UrlEncode(str, e); 229public static string? UrlDecode(string? str, Encoding e) => HttpEncoder.UrlDecode(str, e); 231private static string UrlDecode(ReadOnlySpan<char> str, Encoding e) => HttpEncoder.UrlDecode(str, e); 234public static string? UrlDecode(byte[]? bytes, int offset, int count, Encoding e) =>

System\Web\Util\HttpEncoder.cs (8)

241internal static string? UrlDecode(byte[]? bytes, int offset, int count, Encoding encoding) 306internal static string? UrlDecode(string? value, Encoding encoding) 316internal static string UrlDecode(ReadOnlySpan<char> value, Encoding encoding) 459internal static byte[] UrlEncode(string str, Encoding e) 569byte[] bytes = ArrayPool<byte>.Shared.Rent(Encoding.UTF8.GetMaxByteCount(toEncode.Length)); 570int utf8Length = Encoding.UTF8.GetBytes(toEncode, bytes); 626private readonly Encoding _encoding; 638internal UrlDecoder(Span<char> charBuffer, Span<byte> byteBuffer, Encoding encoding)

System.Web.Services.Description (1)

System\Web\Services\Description\ServiceDescription.cs (1)

266StreamReader reader = new StreamReader(fileName, Encoding.Default, true);

System.Windows.Forms (30)

System\Resources\ResXDataNode.cs (2)

180: new ResXFileRef(FileRefFullPath, FileRefType!, Encoding.GetEncoding(FileRefTextEncoding)); 613? new ResXFileRef(FileRefFullPath, FileRefType, Encoding.GetEncoding(FileRefTextEncoding))

System\Resources\ResxFileRef.Converter.cs (3)

111Encoding textFileEncoding = parts.Length > 2 ? Encoding.GetEncoding(parts[2]) : Encoding.Default;

System\Resources\ResXFileRef.cs (2)

34public ResXFileRef(string fileName, string typeName, Encoding textFileEncoding) : this(fileName, typeName) 46public Encoding? TextFileEncoding { get; }

System\Resources\ResXResourceWriter.cs (2)

161_xmlTextWriter = new XmlTextWriter(_stream, Encoding.UTF8); 166_xmlTextWriter = new XmlTextWriter(_fileName, Encoding.UTF8);

System\Windows\Forms\Control.cs (3)

19using Encoding = System.Text.Encoding; 6500bytes = Encoding.Unicode.GetBytes(value); 6501nullBytes = Encoding.Unicode.GetBytes(nullChar);

System\Windows\Forms\Controls\DataGridView\DataGridView.Methods.cs (8)

8155byte[] sourceBytes = Encoding.Unicode.GetBytes(sbContent.ToString()); 8156byte[] destinationBytes = Encoding.Convert(Encoding.Unicode, Encoding.UTF8, sourceBytes); 8179sourceBytes = Encoding.Unicode.GetBytes(sbContent.ToString()); 8180destinationBytes = Encoding.Convert(Encoding.Unicode, Encoding.UTF8, sourceBytes);

System\Windows\Forms\Controls\RichTextBox\RichTextBox.cs (5)

2826encodedBytes = Encoding.Unicode.GetBytes(str); 2831encodedBytes = (CodePagesEncodingProvider.Instance.GetEncoding(0) ?? Encoding.UTF8).GetBytes(str); 2875string str = (CodePagesEncodingProvider.Instance.GetEncoding(0) ?? Encoding.UTF8).GetString(bytes); 2963result = Encoding.Unicode.GetString(bytes, 0, bytes.Length); 2968result = (CodePagesEncodingProvider.Instance.GetEncoding(0) ?? Encoding.UTF8).GetString(bytes, 0, bytes.Length);

System\Windows\Forms\Controls\TextBox\TextBoxBase.cs (4)

1857Encoding e = Encoding.Default; 1905Encoding e = Encoding.Default;

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 (6)

System\ComponentModel\Design\BinaryEditor.cs (1)

62Encoding.Unicode.GetBytes(stringValue.AsSpan(), buffer.AsSpan());

System\ComponentModel\Design\ByteViewer.cs (2)

343Encoding.Unicode.GetChars(_dataBuf.AsSpan(i, 2), new Span<char>(ref unicodeChar)); 425Encoding.Unicode.GetChars(dataBuf.AsSpan(), text);

System\Windows\Forms\Design\Behavior\BehaviorService.cs (2)

776bytes = Encoding.Unicode.GetBytes(text); 777nullBytes = Encoding.Unicode.GetBytes(nullChar);

System\Windows\Forms\Design\DocumentDesigner.cs (1)

281string clsid = Text.Encoding.Default.GetString(bytes);

System.Windows.Forms.Design.Tests (4)

System\Resources\Tools\StronglyTypedResourceBuilderTests.cs (4)

469Encoding.RegisterProvider(CodePagesEncodingProvider.Instance); 486Encoding.RegisterProvider(CodePagesEncodingProvider.Instance); 490Encoding.GetEncoding(TxtFileEncoding)); 707Assert.Equal("HELLO", Encoding.UTF8.GetString(contents));

System.Windows.Forms.Tests (42)

SerializableTypesTests.cs (2)

29byte[] bytes = Encoding.UTF8.GetBytes(payload); 67Assert.Equal(payload, Encoding.UTF8.GetString(buffer));

System\Resources\ResXFileRef.ConverterTests.cs (2)

84Assert.Equal(expected, Encoding.Default.GetString(result)); 96Assert.Equal(expected, Encoding.Default.GetString(result.ToArray()));

System\Resources\ResXFileRefTests.cs (2)

31Encoding encoding = Encoding.Default;

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 (29)

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);

System.Windows.Forms.UI.IntegrationTests (1)

Infra\ScreenRecordService.cs (1)

448string type = Encoding.ASCII.GetString(chunkType.ToArray());

System.Xaml (1)

src\Microsoft.DotNet.Wpf\src\Shared\System\Windows\Markup\XmlCompatibilityReader.cs (1)

728internal System.Text.Encoding Encoding

Templates.Blazor.Tests (5)

src\Shared\CertificateGeneration\CertificateManager.cs (5)

Templates.Blazor.WebAssembly.Auth.Tests (5)

src\Shared\CertificateGeneration\CertificateManager.cs (5)

Templates.Blazor.WebAssembly.Tests (5)

src\Shared\CertificateGeneration\CertificateManager.cs (5)

Templates.Mvc.Tests (5)

src\Shared\CertificateGeneration\CertificateManager.cs (5)

Templates.Tests (6)

ByteOrderMarkTest.cs (1)

93var expectedBytes = Encoding.UTF8.GetPreamble();

src\Shared\CertificateGeneration\CertificateManager.cs (5)

Test.Utilities (3)

src\RoslynAnalyzers\Utilities\Compiler\Extensions\AdditionalTextExtensions.cs (1)

14private static readonly Encoding s_utf8bom = new UTF8Encoding(encoderShouldEmitUTF8Identifier: true);

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)

52return Encoding.UTF8.GetByteCount(value) == value.Length;

TestReferenceAssembly (6)

OtherDllClass.cs (4)

45return Encoding.ASCII.GetString(bytes); 77return Encoding.ASCII.GetString(bytes); 106output = Encoding.ASCII.GetString(bytes); 135output = Encoding.ASCII.GetString(bytes);

OtherDllStaticMethods.cs (2)

41return Encoding.ASCII.GetString(bytes); 79output = Encoding.ASCII.GetString(bytes);

Text.Analyzers (3)

src\RoslynAnalyzers\Utilities\Compiler\Extensions\AdditionalTextExtensions.cs (1)

14private static readonly Encoding s_utf8bom = new UTF8Encoding(encoderShouldEmitUTF8Identifier: true);

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)

52return Encoding.UTF8.GetByteCount(value) == value.Length;

UIAutomationTypes (2)

src\Microsoft.DotNet.Wpf\src\Shared\MS\Win32\NativeMethodsCLR.cs (2)

2348string result = Encoding.Default.GetString(buffer, offset, i - offset); 2366byte[] bytes = Encoding.Default.GetBytes(s);

UnitTests.Common (10)

TestData.cs (10)

42public static MemberDataSet<Encoding> ValidEncodings 46return new MemberDataSet<Encoding> 48{ Encoding.BigEndianUnicode }, 49{ Encoding.Unicode }, 50{ Encoding.UTF8 }, 55public static MemberDataSet<Encoding> InvalidEncodings 59MemberDataSet<Encoding> data = new MemberDataSet<Encoding>(); 64Encoding encoding = Encoding.GetEncoding(encodingName);

vbc (9)

src\Compilers\Core\CommandLine\BuildProtocol.cs (4)

src\Compilers\Core\CommandLine\CompilerServerLogger.cs (1)

155byte[] bytes = Encoding.UTF8.GetBytes(output);

src\Compilers\Core\CommandLine\ConsoleUtil.cs (2)

14private static readonly Encoding s_utf8Encoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false); 22Encoding savedEncoding = Console.OutputEncoding;

src\Compilers\Shared\BuildClient.cs (1)

108System.Text.Encoding.RegisterProvider(System.Text.CodePagesEncodingProvider.Instance);

src\Compilers\Shared\BuildServerConnection.cs (1)

578var bytes = sha.ComputeHash(Encoding.UTF8.GetBytes(pipeNameInput));

VBCSCompiler (9)

src\Compilers\Core\CommandLine\BuildProtocol.cs (4)

src\Compilers\Core\CommandLine\CompilerServerLogger.cs (1)

155byte[] bytes = Encoding.UTF8.GetBytes(output);

src\Compilers\Core\CommandLine\ConsoleUtil.cs (2)

14private static readonly Encoding s_utf8Encoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false); 22Encoding savedEncoding = Console.OutputEncoding;

src\Compilers\Shared\BuildClient.cs (1)

108System.Text.Encoding.RegisterProvider(System.Text.CodePagesEncodingProvider.Instance);

src\Compilers\Shared\BuildServerConnection.cs (1)

578var bytes = sha.ComputeHash(Encoding.UTF8.GetBytes(pipeNameInput));

VBCSCompiler.UnitTests (6)

CompilerServerTests.cs (6)

149private static (T Result, string Output) UseTextWriter<T>(Encoding encoding, Func<TextWriter, T> func) 182Encoding redirectEncoding = null, 330var result = RunCommandLineCompiler(CSharpCompilerClientExecutable, $"/shared:{serverData.PipeName} /nologo hello.cs", _tempDirectory, files, redirectEncoding: Encoding.ASCII, shouldRunOnServer: false); 371redirectEncoding: Encoding.ASCII, 1155redirectEncoding: Encoding.ASCII); 1178redirectEncoding: Encoding.ASCII);

VisualBasicErrorFactsGenerator (1)

Program.vb (1)

53File.WriteAllText(outputPath, outputText.ToString(), Encoding.UTF8)

VisualBasicSyntaxGenerator (6)

Program.vb (6)

78Using output As New StreamWriter(New FileStream(mainFile, FileMode.Create, FileAccess.Write), Encoding.UTF8) 126Using output As New StreamWriter(New FileStream(outputFile, FileMode.Create, FileAccess.Write), Encoding.UTF8) 142Using output As New StreamWriter(New FileStream(outputFile, FileMode.Create, FileAccess.Write), Encoding.UTF8) 161Using output As New StreamWriter(New FileStream(mainFile, FileMode.Create, FileAccess.Write), Encoding.UTF8) 172Using output As New StreamWriter(New FileStream(syntaxFile, FileMode.Create, FileAccess.Write), Encoding.UTF8) 178Using output As New StreamWriter(New FileStream(internalFile, FileMode.Create, FileAccess.Write), Encoding.UTF8)

WebSocketSample (2)

Program.cs (2)

37var bytes = Encoding.UTF8.GetBytes(line); 59Console.WriteLine(Encoding.UTF8.GetString(buffer, 0, result.Count));

WebTransportInteractiveSampleApp (2)

Program.cs (2)

103var message = Encoding.Default.GetString(memory[..length].ToArray()); 128await ApplySpecialCommands(session, Encoding.Default.GetString(outputMemory.ToArray()));

WebTransportSampleApp (1)

Program.cs (1)

39Console.WriteLine(System.Text.Encoding.Default.GetString(memory.Span));