GetBytes

4 overrides of GetBytes

dotnet-svcutil-lib (1)

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

240public override byte[] GetBytes(string s)

System.Console (1)

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

98public override byte[] GetBytes(string s)

System.Private.CoreLib (1)

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

40public override byte[] GetBytes(string s)

System.Private.Xml (1)

System\Xml\XmlEncoding.cs (1)

239public override byte[] GetBytes(string s)

1799 references to GetBytes

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.Confluent.Kafka (1)

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

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

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

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

192var jsonData = Encoding.UTF8.GetBytes(jsonString);

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;

Aspire.Dashboard.Components.Tests (9)

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

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

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

Aspire.Hosting (4)

Dashboard\ResourceServiceOptions.cs (1)

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

DistributedApplicationBuilder.cs (2)

215var appHostNameShaBytes = SHA256.HashData(Encoding.UTF8.GetBytes(appHostName)); 220var appHostShaBytes = SHA256.HashData(Encoding.UTF8.GetBytes(AppHostPath));

Utils\ImageNameGenerator.cs (1)

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

Aspire.Hosting.Azure.Tests (1)

AzureEventHubsExtensionsTests.cs (1)

101await producerClient.SendAsync([new EventData(Encoding.UTF8.GetBytes("hello worlds"))]);

Aspire.Hosting.Kubernetes (1)

Yaml\ByteArrayStringYamlConverter.cs (1)

24return string.IsNullOrEmpty(scalar.Value) ? null : Encoding.UTF8.GetBytes(scalar.Value);

Aspire.Hosting.RabbitMQ.Tests (2)

RabbitMQFunctionalTests.cs (2)

85var body = Encoding.UTF8.GetBytes(message); 148var body = Encoding.UTF8.GetBytes(message);

Aspire.Hosting.Tests (10)

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

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

Aspire.Templates.Tests (1)

TemplateTestsBase.cs (1)

371byte[] bytes = utf8.GetBytes(name);

AzureFunctionsEndToEnd.ApiService (2)

Program.cs (2)

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

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

ClientSample (1)

RawSample.cs (1)

106await output.WriteAsync(Encoding.UTF8.GetBytes(result));

CodeGenerator (6)

HttpUtilities\HttpUtilities.cs (1)

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

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

472public byte[] Bytes => Encoding.ASCII.GetBytes($"\r\n{Name}: ");

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\Http3\QPack\H3StaticTable.Http3.cs (2)

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

ConfigurationSchemaGenerator.Tests (1)

GeneratorTests.cs (1)

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

csc (2)

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

CustomAuthorizationFailureResponse (1)

Authorization\SampleAuthorizationMiddlewareResultHandler.cs (1)

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

dotnet-dev-certs (1)

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

677bytePayload = Encoding.ASCII.GetBytes(AspNetHttpsOidFriendlyName);

dotnet-razorpagegenerator (1)

Program.cs (1)

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

dotnet-svcutil-lib (17)

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

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

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

470return Base64Encoding.GetBytes(XmlConverter.StripWhitespace(GetString()));

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

397return UTF8Encoding.GetBytes(value);

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

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

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

470byte[] newBytes = _encoding != null ? _encoding.GetBytes(tmp) : s_UTF8Encoding.GetBytes(tmp);

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

150byte[] bytes = e.GetBytes(str); 172byte[] bytes = e.GetBytes(str);

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

75byte[] buffer = CanonicalFormWriter.Utf8WithoutPreamble.GetBytes(s);

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

579byte[] inputBytes = new UTF8Encoding().GetBytes(inputString);

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

141_fragment1 = encoding.GetBytes(xml1); 142_fragment2 = encoding.GetBytes(xml2); 143_fragment3 = encoding.GetBytes(xml3); 144_fragment4 = encoding.GetBytes(xml4);

Metadata\ServiceDescriptor.cs (1)

128MemoryStream stream = new MemoryStream(encoding.GetBytes(xmlReader.ReadOuterXml()));

ExceptionHandlerSample (1)

StartupWithWebSocket.cs (1)

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

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

http2cat (7)

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

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

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

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

IIS.Common.TestLib (1)

TestConnections.cs (1)

66var bytes = Encoding.ASCII.GetBytes(string.Join("\r\n", lines));

IIS.FunctionalTests (12)

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

61var byteArray = new UTF8Encoding().GetBytes(username + ":" + password);

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

162await h2Connection.SendDataAsync(1, Encoding.UTF8.GetBytes("Hello World"), endStream: true); 231await h2Connection.SendDataAsync(1, Encoding.UTF8.GetBytes("Hello World"), endStream: true);

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

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

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

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

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

IIS.LongTests (7)

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

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

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

IIS.Microbenchmarks (1)

PlaintextBenchmark.cs (1)

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

IIS.NewHandler.FunctionalTests (7)

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

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

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

IIS.NewShim.FunctionalTests (7)

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

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

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

IISExpress.FunctionalTests (12)

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

61var byteArray = new UTF8Encoding().GetBytes(username + ":" + password);

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

162await h2Connection.SendDataAsync(1, Encoding.UTF8.GetBytes("Hello World"), endStream: true); 231await h2Connection.SendDataAsync(1, Encoding.UTF8.GetBytes("Hello World"), endStream: true);

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

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

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

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

illink (1)

Linker\CustomSymbolWriter.cs (1)

75 writer.Write (Encoding.UTF8.GetBytes (GetOriginalPdbPath ()));

Infrastructure.Common (2)

SafeKeychainHandle.cs (2)

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

InMemory.FunctionalTests (167)

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

Http2\Http2StreamTests.cs (34)

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

63await requestStream.SendDataAsync(Encoding.ASCII.GetBytes("Hello world"), endStream: true); 108await requestStream.SendDataAsync(Encoding.ASCII.GetBytes("Hello world"), endStream: false); 117await requestStream.SendDataAsync(Encoding.ASCII.GetBytes($"End"), endStream: true); 818await requestStream.SendDataAsync(Encoding.ASCII.GetBytes($"Hello world {index}")); 830await requestStream.SendDataAsync(Encoding.ASCII.GetBytes($"End {index}"), endStream: true);

Http3\Http3StreamTests.cs (10)

36await requestStream.SendDataAsync(Encoding.ASCII.GetBytes("Hello world"), endStream: true); 769var payload = Encoding.ASCII.GetBytes("hello world"); 800var payload = Encoding.ASCII.GetBytes("hello,"); 804var secondPayload = Encoding.ASCII.GetBytes(" world"); 1961await requestStream.SendDataAsync(Encoding.UTF8.GetBytes("This is invalid.")); 1989await requestStream.SendDataAsync(Encoding.UTF8.GetBytes("Hello world")); 2023await requestStream.SendDataAsync(Encoding.UTF8.GetBytes("Hello world")); 2025await requestStream.SendDataAsync(Encoding.UTF8.GetBytes("This is invalid.")); 2073await requestStream.SendDataAsync(Encoding.UTF8.GetBytes("Hello world")); 3090var sendTask = requestStream.SendDataAsync(Encoding.ASCII.GetBytes(new string('a', sendSize)));

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

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

RequestTests.cs (6)

1602var response = Encoding.ASCII.GetBytes("goodbye"); 1650var response = Encoding.ASCII.GetBytes("hello"); 1923await response.BodyWriter.WriteAsync(new Memory<byte>(Encoding.ASCII.GetBytes("Hello World"), 0, 11)); 1969await response.BodyWriter.WriteAsync(new Memory<byte>(Encoding.ASCII.GetBytes("Hello World"), 0, 11)); 2052await response.BodyWriter.WriteAsync(new Memory<byte>(Encoding.ASCII.GetBytes("Hello World"), 0, 11)); 2305await connection.Stream.WriteAsync(Encoding.UTF32.GetBytes("£")).DefaultTimeout();

ResponseTests.cs (41)

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

TlsListenerMiddlewareTests.cs (1)

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

InProcessWebSite (3)

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

963await fileStream.WriteAsync(Encoding.UTF8.GetBytes(fileContent), 0, fileContent.Length);

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

138await webSocket.SendAsync(new ArraySegment<byte>(Encoding.ASCII.GetBytes(message)), WebSocketMessageType.Text, true, CancellationToken.None);

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

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

Interop.FunctionalTests (4)

Http2WebSocketInteropTests.cs (2)

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

Http3\Http3RequestTests.cs (1)

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

HttpClientHttp2InteropTests.cs (1)

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

LargeResponseApp (1)

Startup.cs (1)

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

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

Internal\AntiforgeryOptionsSetup.cs (1)

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

Microsoft.AspNetCore.Authentication.Facebook (2)

FacebookHandler.cs (2)

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

Microsoft.AspNetCore.Authentication.MicrosoftAccount (1)

MicrosoftAccountHandler.cs (1)

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

Microsoft.AspNetCore.Authentication.OAuth (1)

OAuthHandler.cs (1)

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

Microsoft.AspNetCore.Authentication.OpenIdConnect (4)

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

119return Encoding.UTF8.GetBytes(model);

Microsoft.AspNetCore.Authentication.Test (15)

CookieTests.cs (1)

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

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

SecureDataFormatTests.cs (1)

69return Encoding.UTF8.GetBytes(model);

TestExtensions.cs (2)

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

WsFederation\CustomStateDataFormat.cs (1)

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

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

PersistentState\PersistentServicesRegistry.cs (1)

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

SupplyParameterFromPersistentComponentStateValueProvider.cs (1)

254SHA256.HashData(Encoding.UTF8.GetBytes(string.Join(".", parts.parentComponentType, parts.componentType, parts.propertyName)));

Microsoft.AspNetCore.Components.Endpoints (2)

Rendering\EndpointHtmlRenderer.Streaming.cs (1)

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

Rendering\TypeNameHash.cs (1)

25typeNameBytes = Encoding.UTF8.GetBytes(typeName);

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

Binding\FormDataMapperTests.cs (3)

2011var expected = new FormFileCollection { new FormFile(new MemoryStream(Encoding.UTF8.GetBytes(expectedString)), 0, expectedString.Length, "file", "file.txt") }; 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")

Builder\TestFileProvider\TestFileInfo.cs (1)

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

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

ElementReferenceJsonConverterTest.cs (4)

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

208var storedString = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes("This string is not even protected")); 330return Encoding.UTF8.GetBytes(fakeProtectedString); 345return Encoding.UTF8.GetBytes(unprotectedString);

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

TargetPickerUi.cs (2)

53var bytes = Encoding.UTF8.GetBytes(msg); 54var bytesWithHeader = Encoding.UTF8.GetBytes($"{bytes.Length}:").Concat(bytes).ToArray();

Microsoft.AspNetCore.Components.WebView (1)

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

PBKDF2\ManagedPbkdf2Provider.cs (1)

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

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.Abstractions (1)

DataProtectionCommonExtensions.cs (1)

163byte[] plaintextAsBytes = EncodingUtil.SecureUtf8Encoding.GetBytes(plaintext);

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

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

677bytePayload = Encoding.ASCII.GetBytes(AspNetHttpsOidFriendlyName);

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

CertificateManagerTests.cs (2)

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.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.Grpc.JsonTranscoding (1)

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

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

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

ConverterTests\JsonConverterWriteTests.cs (1)

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

ServerStreamingServerCallHandlerTests.cs (2)

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

TestObjects\Services\HttpBodyService.cs (1)

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

UnaryServerCallHandlerTests.cs (13)

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

HttpResponseWritingExtensionsTests.cs (2)

39var expected = encoding.GetBytes(inputString); 57var expected = encoding.GetBytes(inputString);

HttpValidationProblemDetailsJsonConverterTest.cs (2)

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

ProblemDetailsJsonConverterTest.cs (3)

25var reader = new Utf8JsonReader(Encoding.UTF8.GetBytes(json)); 42var reader = new Utf8JsonReader(Encoding.UTF8.GetBytes(json)); 137var reader = new Utf8JsonReader(Encoding.UTF8.GetBytes(json));

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

HttpConnectionDispatcherTests.cs (15)

LongPollingTests.cs (4)

75await connection.Transport.Output.WriteAsync(Encoding.UTF8.GetBytes("Hello World")); 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"));

NegotiateProtocolTests.cs (3)

31var responseData = Encoding.UTF8.GetBytes(json); 60var responseData = Encoding.UTF8.GetBytes(payload); 80var responseData = Encoding.UTF8.GetBytes(payload);

ServerSentEventsMessageFormatterTests.cs (2)

20var buffer = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes(payload)); 32var buffer = ReadOnlySequenceFactory.SegmentPerByteFactory.CreateWithContent(Encoding.UTF8.GetBytes(payload));

ServerSentEventsTests.cs (3)

76await connection.Transport.Output.WriteAsync(Encoding.ASCII.GetBytes("Hello")); 101await connection.Transport.Output.WriteAsync(Encoding.ASCII.GetBytes(hText + wText)); 124await connection.Transport.Output.WriteAsync(Encoding.UTF8.GetBytes(message));

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

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

WebSocketsTests.cs (2)

48buffer: new ArraySegment<byte>(Encoding.UTF8.GetBytes("Hello")), 95await connection.Transport.Output.WriteAsync(Encoding.UTF8.GetBytes("Hello"));

Microsoft.AspNetCore.Http.Extensions (1)

SessionExtensions.cs (1)

54session.Set(key, Encoding.UTF8.GetBytes(value));

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

HttpRequestJsonExtensionsTests.cs (9)

70context.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes("1")); 85context.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes("[1,2,]")); 106context.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes("[1,2]")); 124context.Request.Body = new MemoryStream(Encoding.Unicode.GetBytes(@"{""name"": ""激光這兩個字是甚麼意思""}")); 173context.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes("1")); 188context.Request.Body = new MemoryStream(Encoding.Unicode.GetBytes(@"{""name"": ""激光這兩個字是甚麼意思""}")); 217context.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes("[1,2,]")); 238context.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes("[1,2,]")); 260context.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes("[1,2,]"));

RequestDelegateGenerator\RequestDelegateCreationTestBase.cs (1)

138var buffer = encoding.GetBytes(text.ToString());

RequestDelegateGenerator\RequestDelegateCreationTests.Forms.cs (2)

964httpContext.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes(new string('x', 2049))); 1001httpContext.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes(new string('x', 2049)));

RequestDelegateGenerator\RequestDelegateCreationTests.Logging.cs (2)

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

ValidationsGenerator\ValidationsGeneratorTestBase.cs (2)

131var buffer = encoding.GetBytes(text.ToString()); 570var stream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(requestData));

Microsoft.AspNetCore.Http.Microbenchmarks (1)

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

138var buffer = encoding.GetBytes(text.ToString());

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

PushStreamResultTests.cs (3)

15var result = new PushStreamHttpResult(body => body.WriteAsync(Encoding.UTF8.GetBytes("Hello World").AsMemory()).AsTask(), contentType: null); 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();

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

59var byteArray = Encoding.ASCII.GetBytes("Hello World"); 98var byteArray = Encoding.ASCII.GetBytes("Hello World"); 137var byteArray = Encoding.ASCII.GetBytes("Hello World"); 171var byteArray = Encoding.ASCII.GetBytes("Hello World"); 208var byteArray = Encoding.ASCII.GetBytes("Hello World"); 239var byteArray = Encoding.ASCII.GetBytes("Hello World"); 271var byteArray = Encoding.ASCII.GetBytes("Hello World"); 305var byteArray = Encoding.ASCII.GetBytes("Hello World");

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

35var byteArray = Encoding.ASCII.GetBytes("Hello World"); 77var byteArray = Encoding.ASCII.GetBytes("Hello World"); 118var byteArray = Encoding.ASCII.GetBytes("Hello World"); 155var byteArray = Encoding.ASCII.GetBytes("Hello World"); 195var byteArray = Encoding.ASCII.GetBytes("Hello World"); 228var byteArray = Encoding.ASCII.GetBytes("Hello World"); 262var byteArray = Encoding.ASCII.GetBytes("Hello World"); 298var byteArray = Encoding.ASCII.GetBytes("Hello World"); 337var byteArray = Encoding.ASCII.GetBytes(""); 425var readStream = new MemoryStream(Encoding.UTF8.GetBytes("Hello, World!"));

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

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

Microsoft.AspNetCore.Http.Tests (31)

Features\FormFeatureTests.cs (29)

Features\RequestBodyPipeFeatureTests.cs (2)

31context.Request.Body = new MemoryStream(Encoding.ASCII.GetBytes("hahaha")); 36context.Request.Body = new MemoryStream(Encoding.ASCII.GetBytes(expectedString));

Microsoft.AspNetCore.HttpLogging.Tests (14)

HttpLoggingMiddlewareTests.cs (14)

Microsoft.AspNetCore.Identity (1)

IdentityApiEndpointRouteBuilderExtensions.cs (1)

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

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

96var modifierBytes = modifier is not null ? _encoding.GetBytes(modifier) : null; 118var modifierBytes = modifier is not null ? _encoding.GetBytes(modifier) : null;

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

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

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

Microsoft.AspNetCore.InternalTesting.Tests (1)

HttpClientSlimTest.cs (1)

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

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

Formatters\JsonInputFormatterTestBase.cs (23)

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

Infrastructure\JsonResultExecutorTestBase.cs (10)

Infrastructure\ValidationProblemDetailsJsonConverterTest.cs (2)

26var reader = new Utf8JsonReader(Encoding.UTF8.GetBytes(json)); 68var reader = new Utf8JsonReader(Encoding.UTF8.GetBytes(json));

ModelBinding\Binders\BodyModelBinderTests.cs (8)

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.Formatters.Xml.Test (54)

ProblemDetailsWrapperTest.cs (1)

29new MemoryStream(Encoding.UTF8.GetBytes(xml)));

SerializableErrorWrapperTests.cs (1)

67new MemoryStream(Encoding.UTF8.GetBytes(serializableErrorXml)));

ValidationProblemDetailsWrapperTest.cs (3)

33new MemoryStream(Encoding.UTF8.GetBytes(xml))); 89new MemoryStream(Encoding.UTF8.GetBytes(xml))); 127new MemoryStream(Encoding.UTF8.GetBytes(xml)));

XmlDataContractSerializerInputFormatterTest.cs (26)

XmlSerializerInputFormatterTest.cs (23)

Microsoft.AspNetCore.Mvc.FunctionalTests (1)

Infrastructure\ResourceFile.cs (1)

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

Microsoft.AspNetCore.Mvc.IntegrationTests (45)

BindingSourceMetadataProviderIntegrationTest.cs (1)

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

BodyValidationIntegrationTests.cs (19)

ComplexRecordIntegrationTest.cs (3)

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

ComplexTypeIntegrationTestBase.cs (3)

23private static readonly byte[] ByteArrayContent = Encoding.BigEndianUnicode.GetBytes("abcd"); 3704var stream = new MemoryStream(new UTF8Encoding(encoderShouldEmitUTF8Identifier: false).GetBytes(content)); 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.Test (55)

JsonResultTest.cs (1)

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

NewtonsoftJsonInputFormatterTest.cs (14)

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

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

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

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

Cache\CacheTagKey.cs (1)

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

Cache\DistributedCacheTagHelperFormatter.cs (1)

28var serialized = Encoding.UTF8.GetBytes(context.Html.ToString());

Cache\DistributedCacheTagHelperService.cs (1)

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

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

ControllerUnitTestabilityTests.cs (2)

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

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

TestFileInfo.cs (1)

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

TestRazorCompiledItem.cs (2)

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

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

SnapshotTestHelper.cs (1)

126var buffer = encoding.GetBytes(text.ToString());

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

TestUtils.cs (1)

282var data = Encoding.UTF8.GetBytes(text);

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

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

Helpers.cs (1)

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

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

Http2Tests.cs (2)

193await h2Connection.SendDataAsync(1, Encoding.UTF8.GetBytes("Hello World"), endStream: true); 257await h2Connection.SendDataAsync(1, Encoding.UTF8.GetBytes("Hello World"), endStream: true);

HttpsTests.cs (2)

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

Listener\RequestHeaderTests.cs (1)

222byte[] request = encoding.GetBytes(builder.ToString());

Listener\RequestTests.cs (1)

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

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

71var request = Encoding.ASCII.GetBytes(builder.ToString()); 271byte[] request = Encoding.ASCII.GetBytes(builder.ToString());

RequestTests.cs (9)

ResponseBodyTests.cs (2)

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

ResponseHeaderTests.cs (1)

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

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

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

Microsoft.AspNetCore.Server.IIS (4)

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

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

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

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

Internal\Http2\Http2Connection.cs (1)

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

Internal\Infrastructure\HttpUtilities.cs (1)

614var bytes = Encoding.ASCII.GetBytes($"\r\nAlt-Svc: " + text);

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

677bytePayload = Encoding.ASCII.GetBytes(AspNetHttpsOidFriendlyName);

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

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

ChunkWriterTests.cs (1)

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

Http1\Http1ConnectionTests.cs (36)

HttpParserTests.cs (33)

HttpRequestHeadersTests.cs (26)

HttpUtilitiesTest.cs (4)

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

KnownStringsTests.cs (18)

MessageBodyTests.cs (2)

1403var bytes = encoding.GetBytes(expected); 1415var bytes = encoding.GetBytes(expected);

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

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

472public byte[] Bytes => Encoding.ASCII.GetBytes($"\r\n{Name}: ");

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

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

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

41private static readonly byte[] _headerValueBytes = Encoding.ASCII.GetBytes(_headerValueString);

StartLineTests.cs (17)

TestHelpers\TestInput.cs (1)

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

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

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

InMemoryTransportBenchmark.cs (1)

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

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

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

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

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

QuicConnectionContextTests.cs (1)

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

QuicConnectionListenerTests.cs (1)

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

QuicStreamContextTests.cs (1)

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

QuicTestHelpers.cs (1)

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

Microsoft.AspNetCore.Session (2)

CookieProtection.cs (1)

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

EncodedKey.cs (1)

18KeyBytes = Encoding.UTF8.GetBytes(key);

Microsoft.AspNetCore.Shared.Tests (48)

PathNormalizerTests.cs (1)

82var data = Encoding.ASCII.GetBytes(input);

runtime\Http2\DynamicTableTest.cs (6)

runtime\Http2\HPackDecoderTest.cs (15)

runtime\Http2\HuffmanDecodingTests.cs (14)

runtime\Http3\QPackDecoderTest.cs (1)

41private static readonly byte[] _headerValueBytes = Encoding.ASCII.GetBytes(_headerValueString);

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

UrlDecoderTests.cs (6)

93var source = Encoding.UTF8.GetBytes("%00"); 122Assert.True(source.AsSpan(0, length).SequenceEqual(Encoding.UTF8.GetBytes(input).AsSpan())); 132Assert.True(source.AsSpan(0, length).SequenceEqual(Encoding.UTF8.GetBytes("/").AsSpan())); 160Assert.True(source.AsSpan(0, length).SequenceEqual(Encoding.UTF8.GetBytes(input).AsSpan())); 197var input = Encoding.UTF8.GetBytes((string)x[0]); 198var expected = Encoding.UTF8.GetBytes((string)x[1]);

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

HubProtocolVersionTests.cs (1)

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

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

HttpConnectionTests.Transport.cs (7)

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

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

TestConnection.cs (2)

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

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

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

19var buffer = Encoding.UTF8.GetBytes("ABC");

Internal\Formatters\TextMessageParserTests.cs (4)

17var message = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes("ABC\u001e")); 27var message = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes("ABC")); 34var message = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes("ABC\u001eXYZ\u001e")); 44var message = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes("ABC\u001eXYZ\u001e123"));

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

53var data = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes(input)); 90var data = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes(input)); 104var data = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes(input)); 130var data = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes(json)); 163var data = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes(json)); 196var data = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes(json));

Internal\Protocol\JsonHubProtocolTestsBase.cs (15)

Internal\Protocol\NewtonsoftJsonHubProtocolTests.cs (2)

51var data = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes(input)); 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 (2)

142var expectedData = Encoding.UTF8.GetBytes(fourCircles); 171var expectedData = Encoding.UTF8.GetBytes(fourCircles);

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

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

Microsoft.AspNetCore.SignalR.Core (1)

Internal\Utf8HashLookup.cs (1)

39var encodedValue = Encoding.UTF8.GetBytes(value);

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

ClientProxyTests.cs (9)

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

EndToEndTests.cs (4)

102var bytes = Encoding.UTF8.GetBytes(message); 140var bytes = Encoding.UTF8.GetBytes(message); 274var bytes = Encoding.UTF8.GetBytes(message); 331var bytes = Encoding.UTF8.GetBytes(message);

HttpHeaderConnectionHandler.cs (1)

28var data = Encoding.UTF8.GetBytes(string.Join(",", headerValues));

HubConnectionHandlerTests.cs (16)

WebSocketsTransportTests.cs (2)

112await webSocketsTransport.Output.WriteAsync(Encoding.UTF8.GetBytes("User-Agent")); 143await webSocketsTransport.Output.WriteAsync(Encoding.UTF8.GetBytes(HeaderNames.XRequestedWith));

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

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

128var character = Encoding.ASCII.GetBytes("a"); 222await requestStream.WriteAsync(Encoding.UTF8.GetBytes("Hello world")).AsTask().DefaultTimeout(); 326await requestStream.WriteAsync(Encoding.UTF8.GetBytes("SENT")).AsTask().DefaultTimeout(); 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.Tests (10)

SendReceiveTests.cs (2)

17var sendBuffer = Encoding.UTF8.GetBytes(message); 34var sendBuffer = Encoding.UTF8.GetBytes(message);

WebSocketMiddlewareTests.cs (8)

Microsoft.AspNetCore.WebUtilities (3)

FormPipeReader.cs (2)

66_otherEqualEncoding = _encoding.GetBytes("="); 67_otherAndEncoding = _encoding.GetBytes("&");

MultipartBoundary.cs (1)

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

Microsoft.AspNetCore.WebUtilities.Microbenchmarks (7)

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

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

FileBufferingWriteStreamTests.cs (2)

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

FormPipeReaderTests.cs (36)

FormReaderTests.cs (1)

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

HttpResponseStreamWriterTest.cs (3)

629var expectedBytes = encoding.GetBytes(data); 664var expectedBytes = encoding.GetBytes(data); 689var expectedBytes = encoding.GetBytes("Hello, World!");

MultipartReaderTests.cs (5)

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

PagedByteBufferTest.cs (3)

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

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

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

Microsoft.Build (5)

CommunicationsUtilities.cs (1)

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

Evaluation\IntrinsicFunctions.cs (2)

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

Logging\BinaryLogger\ProjectImportsCollector.cs (1)

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

Utilities\NuGetFrameworkWrapper.cs (1)

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

Microsoft.Build.Framework (2)

EncodingUtilities.cs (1)

191var unicodeBytes = unicodeEncoding.GetBytes(stringToEncode);

Telemetry\ActivityExtensions.cs (1)

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

Microsoft.Build.Tasks.CodeAnalysis (2)

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

Microsoft.Build.Tasks.Core (3)

BootstrapperUtil\ResourceUpdater.cs (1)

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

ManifestUtil\mansign2.cs (1)

870byte[] licenseXml = Encoding.UTF8.GetBytes(licenseDom.OuterXml);

ResourceHandling\MSBuildResXReader.cs (1)

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

Microsoft.Build.Tasks.UnitTests (1)

DownloadFile_Tests.cs (1)

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

Microsoft.CodeAnalysis (5)

CommandLine\CommonCompiler.cs (1)

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

CryptographicHashProvider.cs (1)

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

DiaSymReader\Writer\SymUnmanagedWriterImpl.cs (1)

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

InternalUtilities\StringExtensions.cs (1)

289result = s_lazyUtf8.GetBytes(s);

PEWriter\MetadataWriter.DynamicAnalysis.cs (1)

244BlobHandle partIndex = GetOrAddBlob(ImmutableArray.Create(MetadataWriter.s_utf8Encoding.GetBytes(part)));

Microsoft.CodeAnalysis.CodeStyle (1)

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

289result = s_lazyUtf8.GetBytes(s);

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

CommandLineTests.cs (3)

2307byte[] slContent = Encoding.UTF8.GetBytes(@"{ ""documents"" : {} }"); 7685var explicitManifestStream = new MemoryStream(Encoding.UTF8.GetBytes(explicitManifest)); 9066return new TestStream(backingStream: new MemoryStream(Encoding.UTF8.GetBytes(@"

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

PdbSourceDocument\PdbSourceDocumentTests.cs (3)

792using var ms = new MemoryStream(encoding.GetBytes(source)); 821using var ms = new MemoryStream(encoding.GetBytes(source)); 850using var ms = new MemoryStream(encoding.GetBytes(source));

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

PDB\PDBSourceLinkTests.cs (2)

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

PDB\PortablePdbTests.cs (2)

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

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

Attributes\AttributeTests_Assembly.cs (1)

354Assert.Equal(utf8.GetString(utf8.GetBytes("\uD800")), m.ContainingAssembly.Identity.CultureName);

Attributes\AttributeTests_MarshalAs.cs (6)

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]]"); 834{ "SafeArray5", new byte[] { 0x1d, 0x09, 0x75 }.Append(e.GetBytes("System.Collections.Generic.List`1[X][][], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")) }, 1039{ "CustomMarshaler6", new byte[] { 0x2c, 0x00, 0x00, 0x60 }.Append(Encoding.UTF8.GetBytes("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\0")) }, 1041{ "CustomMarshaler8", new byte[] { 0x2c, 0x00, 0x00, 0x59 }.Append(Encoding.UTF8.GetBytes("System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089\0")) },

Attributes\AttributeTests_Security.cs (1)

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

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

ScriptTests.cs (6)

52var script = CSharpScript.Create(new MemoryStream(Encoding.UTF8.GetBytes("1 + 2")), ScriptOptions); 148var script = CSharpScript.Create(new MemoryStream(Encoding.UTF8.GetBytes("1 + 2")), ScriptOptions); 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)); 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));

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

Compilation\CompilationAPITests.cs (2)

2264var appConfig = new MemoryStream(Encoding.UTF8.GetBytes( 2324var appConfig = new MemoryStream(Encoding.UTF8.GetBytes(

Microsoft.CodeAnalysis.EditorFeatures.UnitTests (3)

Workspaces\TextFactoryTests.cs (3)

44new ASCIIEncoding().GetBytes("Test"), 57new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true).GetBytes("Test"), 72.. new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true).GetBytes("Test"),

Microsoft.CodeAnalysis.ExpressionEvaluator.ExpressionCompiler (1)

CustomTypeInfo.cs (1)

150return new ReadOnlyCollection<byte>(Encoding.UTF8.GetBytes(str));

Microsoft.CodeAnalysis.ExpressionEvaluator.ResultProvider (1)

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

150return new ReadOnlyCollection<byte>(Encoding.UTF8.GetBytes(str));

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

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

150return new ReadOnlyCollection<byte>(Encoding.UTF8.GetBytes(str));

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

EditAndContinue\Extensions.cs (1)

99return BlobContentId.FromHash(Encoding.UTF8.GetBytes(projectName.PadRight(20, '\0'))).Guid;

Microsoft.CodeAnalysis.InteractiveHost (1)

Interactive\Core\InteractiveHost.RemoteService.cs (1)

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

Features\Diagnostics\DiagnosticDataExtensions.cs (1)

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

Microsoft.CodeAnalysis.Test.Utilities (4)

FX\EncodingUtilities.cs (1)

16var content = encoding.GetBytes(text);

Metadata\MetadataReaderUtils.cs (1)

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

Mocks\TestSourceReferenceResolver.cs (1)

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

TestableFile.cs (1)

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

Microsoft.CodeAnalysis.UnitTests (17)

EmbeddedTextTests.cs (7)

116var bytes = Encoding.UTF8.GetBytes(SmallSource); 130var bytes = Encoding.UTF8.GetBytes(SmallSource); 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); 194AssertEx.Equal(Encoding.Unicode.GetPreamble().Concat(Encoding.Unicode.GetBytes(LargeSource)), Decompress(text.Blob.Skip(4))); 230byte[] bytes = Encoding.ASCII.GetBytes(LargeSource);

StringTableTests.cs (1)

89fixed (byte* ptr = Encoding.ASCII.GetBytes(ascii))

Text\SourceTextStreamTests.cs (1)

55Assert.True(buffer.Take(baseText.Length).SequenceEqual(encoding.GetBytes(baseText)));

Text\SourceTextTests.cs (6)

59var bytes = s_unicode.GetBytes(HelloWorld); 73var bytes = utf8BOM.GetPreamble().Concat(utf8BOM.GetBytes("abc")).ToArray(); 87var bytes = s_unicode.GetBytes(HelloWorld); 101var bytes = s_unicode.GetBytes(HelloWorld); 219var e1 = EncodedStringText.Create(new MemoryStream(s_unicode.GetBytes(HelloWorld)), s_unicode); 220var e2 = EncodedStringText.Create(new MemoryStream(s_utf8.GetBytes(HelloWorld)), s_utf8);

Text\StringTextDecodingTests.cs (1)

218string path = Temp.CreateFile().WriteAllBytes(encoding.GetBytes(expectedText)).Path;

Text\StringTextTest.cs (1)

259var bytes = Encoding.UTF8.GetBytes("\u1234");

Microsoft.CodeAnalysis.VisualBasic (1)

Symbols\AnonymousTypes\CRC32.vb (1)

20crc32 = Crc32Update(crc32, s_encoding.GetBytes(CaseInsensitiveComparison.ToLower(name)))

Microsoft.CodeAnalysis.VisualBasic.CommandLine.UnitTests (1)

CommandLineTests.vb (1)

9647backingStream:=New MemoryStream(Encoding.UTF8.GetBytes("

Microsoft.CodeAnalysis.VisualBasic.Emit.UnitTests (7)

Attributes\AttributeTests_MarshalAs.vb (4)

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]]") 688{"SafeArray5", New Byte() {&H1D, &H9, &H75}.Append(e.GetBytes("System.Collections.Generic.List`1[X][][], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"))},

Emit\CompilationEmitTests.vb (1)

3578Dim hexFileContent = PermissionSetAttributeWithFileReference.ConvertToHex(New MemoryStream(Encoding.UTF8.GetBytes(text)))

PDB\PortablePdbTests.vb (2)

190Dim sourceLinkBlob = Encoding.UTF8.GetBytes(" 226Dim sourceLinkBlob = Encoding.UTF8.GetBytes("

Microsoft.CodeAnalysis.Workspaces (5)

Log\AnalyzerNameForTelemetry.cs (1)

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

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

289result = s_lazyUtf8.GetBytes(s);

Workspace\Solution\SourceGeneratedDocumentIdentity.cs (3)

57hashInput.AddRange(Encoding.Unicode.GetBytes(assemblyNameToHash)); 59hashInput.AddRange(Encoding.Unicode.GetBytes(generatorIdentity.TypeName)); 61hashInput.AddRange(Encoding.Unicode.GetBytes(hintName));

Microsoft.CodeAnalysis.Workspaces.MSBuild (1)

Rpc\RpcClient.cs (1)

162var requestJsonBytes = JsonSettings.StreamEncoding.GetBytes(requestJson);

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

MSBuild\ProjectFile\ProjectFileLoader.cs (1)

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

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

289result = s_lazyUtf8.GetBytes(s);

Microsoft.CodeAnalysis.Workspaces.UnitTests (6)

Remote\ServiceDescriptorTests.cs (2)

191Assert.Throws<NotImplementedException>(() => original.GetBytes("\u1234")); 192AssertEx.Equal(new byte[] { 0x3f }, deserialized.GetBytes("\u1234"));

SolutionTests\SolutionTests.cs (1)

1603var bytes = new UTF8Encoding(encoderShouldEmitUTF8Identifier: true).GetBytes("Text");

UtilityTest\XmlDocumentationProviderTests.cs (1)

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

XxHash128Tests.cs (2)

38byte[] input = Encoding.ASCII.GetBytes(test.Ascii); 101byte[] asciiBytes = Encoding.ASCII.GetBytes(test.Ascii);

Microsoft.Data.Analysis (4)

DataFrameColumns\ArrowStringDataFrameColumn.cs (4)

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>); 692ret.Append(funcResult != null ? encoding.GetBytes(funcResult) : default(ReadOnlySpan<byte>));

Microsoft.Data.Analysis.Tests (3)

ArrowStringColumnTests.cs (1)

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

DataFrame.IOTests.cs (1)

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

TextFieldParserTests.cs (1)

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

Microsoft.DotNet.Arcade.Sdk (2)

src\GenerateSourcePackageSourceLinkTargetsFile.cs (1)

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

src\InstallDotNetCore.cs (1)

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

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

src\AzureDevOpsNugetFeedAssetPublisher.cs (1)

55Convert.ToBase64String(Encoding.ASCII.GetBytes($":{_accessToken}")))

src\CreateAzureDevOpsFeed.cs (1)

142Convert.ToBase64String(Encoding.ASCII.GetBytes(string.Format("{0}:{1}", "", AzureDevOpsPersonalAccessToken))));

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

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

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

src\GenerateGuidFromName.cs (1)

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

src\RpmHeader.cs (2)

271byte[] bytes = Encoding.UTF8.GetBytes((string)entry.Value); 286byte[] bytes = Encoding.UTF8.GetBytes(str);

Microsoft.DotNet.Build.Tasks.VisualStudio (1)

Vsix\GetPkgDefAssemblyDependencyGuid.cs (1)

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

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

Utils.cs (2)

24byte[] bytes = Encoding.UTF8.GetBytes(value); 140byte[] nameBytes = Encoding.Unicode.GetBytes(name);

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

Payloads\SingleFilePayload.cs (1)

24: this(name, encoding.GetBytes(content))

StorageHelpers\ContainerBase.cs (1)

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

Microsoft.DotNet.Helix.Sdk (1)

AzureDevOpsTask.cs (1)

64Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(Encoding.UTF8.GetBytes("unused:" + AccessToken))),

Microsoft.DotNet.Open.Api.Tools.Tests (1)

OpenApiTestBase.cs (1)

141var byteArray = Encoding.ASCII.GetBytes(result.Item1);

Microsoft.DotNet.SignCheckLibrary (1)

Utils.cs (1)

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

Microsoft.Extensions.AI.Abstractions (1)

Contents\DataUriParser.cs (1)

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

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

VerbatimHttpHandler.cs (1)

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

Microsoft.Extensions.Caching.Abstractions (2)

DistributedCacheExtensions.cs (2)

75cache.Set(key, Encoding.UTF8.GetBytes(value), options); 107return cache.SetAsync(key, Encoding.UTF8.GetBytes(value), options, token);

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.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.Physical (1)

PollingWildCardChangeToken.cs (1)

23private static readonly byte[] Separator = Encoding.Unicode.GetBytes("|");

Microsoft.Extensions.Hosting.Systemd (1)

ServiceState.cs (1)

34_data = Encoding.UTF8.GetBytes(state);

Microsoft.Extensions.Http.Diagnostics.Tests (4)

Logging\HttpClientLoggerTest.cs (2)

859using var requestContent = new StreamContent(new NotSeekableStream(new(Encoding.UTF8.GetBytes(requestInput)))); 870using var responseContent = new StreamContent(new NotSeekableStream(new(Encoding.UTF8.GetBytes(responseInput))));

Logging\HttpResponseBodyReaderTest.cs (2)

155Content = new StreamContent(new NotSeekableStream(new(Encoding.UTF8.GetBytes(bigContent)))) 182Content = new StreamContent(new NotSeekableStream(new(Encoding.UTF8.GetBytes(bigContent))))

Microsoft.Extensions.Identity.Core (3)

Rfc6238AuthenticationService.cs (2)

96var modifierBytes = modifier is not null ? _encoding.GetBytes(modifier) : null; 118var modifierBytes = modifier is not null ? _encoding.GetBytes(modifier) : null;

UserManager.cs (1)

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

Microsoft.JSInterop (1)

Infrastructure\DotNetDispatcher.cs (1)

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.SourceGen (1)

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

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

Microsoft.Maui.Graphics (1)

Text\XmlAttributedTextWriter.cs (1)

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

Microsoft.ML.AutoML.Tests (1)

TextFileSampleTests.cs (1)

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

Microsoft.ML.FastTree (2)

Utils\ToByteArrayExtensions.cs (2)

229byte[] bytes = Encoding.Unicode.GetBytes(a); 237byte[] bytes = Encoding.Unicode.GetBytes(a);

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.TestFramework (1)

BytesStreamSource.cs (1)

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

Microsoft.ML.Tokenizers (1)

Model\TiktokenTokenizer.cs (1)

143_decoder![specialToken.Value] = Encoding.UTF8.GetBytes(specialToken.Key);

Microsoft.ML.Tokenizers.Tests (2)

DoubleArrayTrieTest.cs (2)

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

Microsoft.VisualBasic.Core (2)

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

1034Dim Bytes() As Byte = m_Encoding.GetBytes(s) 1873Dim Bytes() As Byte = m_Encoding.GetBytes(sTemp)

Microsoft.VisualStudio.LanguageServices (1)

ColorSchemes\ColorSchemeApplier.RegistryItemConverter.cs (1)

100bytes.Write(Encoding.ASCII.GetBytes(color.Name), 0, color.Name.Length);

Microsoft.VisualStudio.LanguageServices.CSharp.UnitTests (1)

PersistentStorage\AbstractPersistentStorageTests.cs (1)

1064var bytes = _encoding.GetBytes(text);

MSBuild (1)

CommunicationsUtilities.cs (1)

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

MSBuildTaskHost (1)

CommunicationsUtilities.cs (1)

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

PlaintextApp (1)

Startup.cs (1)

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

PresentationBuildTasks (1)

MS\Internal\Tasks\TaskFileService.cs (1)

145byte[] baFileContent = utf8Encoding.GetBytes(strFileContent);

PresentationCore (2)

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

287bw.Write( System.Text.Encoding.Unicode.GetBytes( data ) );

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

252byte[] searchArray = System.Text.Encoding.ASCII.GetBytes("BM");

PresentationFramework (5)

MS\Internal\Controls\StickyNote\StickyNoteContentControl.cs (1)

298MemoryStream data = new MemoryStream(encoding.GetBytes(rtfString));

MS\Internal\WindowsRuntime\Generated\WinRT\GuidGenerator.cs (1)

137var data = wrt_pinterface_namespace.ToByteArray().Concat(UTF8Encoding.UTF8.GetBytes(sig)).ToArray();

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

79byte[] sourceBytes = Encoding.Unicode.GetBytes(content.ToString());

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

7751_rtfBytes = Encoding.Default.GetBytes(rtfString);

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

82Stream xamlStream = new MemoryStream(UTF8Encoding.Default.GetBytes(xamlText));

RazorBuildWebSite (1)

UpdateableFileProvider.cs (1)

102return new MemoryStream(Encoding.UTF8.GetBytes(_content));

Replay (2)

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.VisualStudio.Next.UnitTests (2)

Services\ServiceHubServicesTests.cs (1)

519var bytes = encoding.GetBytes(content);

UnifiedSettings\UnifiedSettingsTests.cs (1)

282var fileBytes = Encoding.ASCII.GetBytes(registrationFile);

RoutingSandbox (3)

HelloExtension\HelloMiddleware.cs (2)

21payload.AddRange(Encoding.UTF8.GetBytes("Hello")); 25payload.AddRange(Encoding.UTF8.GetBytes(_helloOptions.Greeter));

UseEndpointRoutingStartup.cs (1)

12private static readonly byte[] _plainTextPayload = Encoding.UTF8.GetBytes("Plain text!");

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

SecurityWebSite (1)

BearerAuth.cs (1)

15Key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(new string('a', 128)));

SignalRSamples (2)

ConnectionHandlers\MessagesConnectionHandler.cs (2)

37await Broadcast(Encoding.UTF8.GetBytes(text)); 60return Broadcast(Encoding.UTF8.GetBytes(text));

SocialWeather (1)

Pipe\PipeWeatherStreamFormatter.cs (1)

56var encodedBytes = utf8.GetBytes(line);

Sockets.FunctionalTests (10)

src\Servers\Kestrel\test\FunctionalTests\MaxRequestBufferSizeTests.cs (1)

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

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

System.Configuration.ConfigurationManager (2)

System\Configuration\DpapiProtectedConfigurationProvider.cs (1)

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

System\Configuration\ImplicitMachineConfigHost.cs (1)

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

System.Console (2)

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

100return _encoding.GetBytes(s);

System\ConsolePal.Unix.cs (1)

1131data = Encoding.UTF8.GetBytes(value);

System.Data.Common (5)

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

323return s_unicodeEncoding.GetBytes(m_value!); 335return cpe.GetBytes(m_value!); 721byte[] rgDataX = s_unicodeEncoding.GetBytes(x.m_value!); 722byte[] rgDataY = s_unicodeEncoding.GetBytes(y.m_value!); 895rgbSortKey = s_unicodeEncoding.GetBytes(m_value!.TrimEnd());

System.Data.Odbc (1)

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

745value = cpe.GetBytes(value.ToString()!);

System.Formats.Tar (1)

System\Formats\Tar\TarHeader.Write.cs (1)

439data.Write(Encoding.UTF8.GetBytes(text));

System.IO.Compression (3)

System\IO\Compression\ZipHelper.cs (3)

211return encoding.GetBytes(text); 227bytes = encoding.GetBytes(text); 235bytes = encoding.GetBytes(text);

System.IO.Ports (2)

System\IO\Ports\SerialPort.cs (2)

1143byte[] readBuffer = _encoding.GetBytes(currentLine.ToString()); 1183bytesToWrite = _encoding.GetBytes(text);

System.Memory.Data (1)

System\BinaryData.cs (1)

144_bytes = Encoding.UTF8.GetBytes(data);

System.Net.Http (14)

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

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

439byte[] buffer = Encoding.UTF8.GetBytes(input);

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

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

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

339byte[] buffer = HttpRuleParser.DefaultHttpEncoding.GetBytes(input); 345return new MemoryStream(HttpRuleParser.DefaultHttpEncoding.GetBytes(input), writable: false);

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\ConnectionPool\HttpConnectionPool.Http2.cs (1)

55_http2AltSvcOriginUri = Encoding.ASCII.GetBytes(sb.ToString());

System\Net\Http\SocketsHttpHandler\Http3RequestStream.cs (1)

1039return HttpConnectionBase.ParseStatusCode(Encoding.ASCII.GetBytes(value));

System\Net\Http\StringContent.cs (1)

97return (encoding ?? DefaultStringEncoding).GetBytes(content);

System.Net.HttpListener (5)

System\Net\HttpListenerRequestUriBuilder.cs (2)

261AppendOctetsPercentEncoded(_requestUriString!, s_utf8Encoding.GetBytes(unicodeString)); 314AppendOctetsPercentEncoded(_requestUriString!, s_utf8Encoding.GetBytes(decodedString));

System\Net\Managed\HttpConnection.cs (1)

458byte[] error = Encoding.Default.GetBytes(str);

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

System\Net\Mail\Attachment.cs (2)

108byte[] buffer = encoding.GetBytes(content); 166byte[] buffer = encoding.GetBytes(content);

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

63buffer = encoding.GetBytes(value);

System\Net\Mime\EncodedStreamFactory.cs (1)

40Encoding.ASCII.GetBytes("=?" + encoding.HeaderName + "?" + (useBase64Encoding ? "B?" : "Q?"));

System\Net\Mime\MimeBasePart.cs (1)

74byte[] buffer = Encoding.ASCII.GetBytes(subStrings[3]);

System\Net\Mime\MimeWriter.cs (1)

25_boundaryBytes = Encoding.ASCII.GetBytes(boundary);

System\Net\Mime\QuotedPrintableStream.cs (1)

297byte[] buffer = encoding.GetBytes(value);

System.Net.Requests (1)

System\Net\CommandStream.cs (1)

197byte[] sendBuffer = Encoding.GetBytes(_commands[_index].Command);

System.Net.Security (3)

System\Net\NegotiateAuthenticationPal.ManagedNtlm.cs (2)

56private static readonly byte[] s_workstation = Encoding.Unicode.GetBytes(Environment.MachineName); 382byte[] blob = Encoding.Unicode.GetBytes(string.Concat(userName.ToUpperInvariant(), domain));

System\Net\Security\SslApplicationProtocol.cs (1)

48this(s_utf8.GetBytes(protocol ?? throw new ArgumentNullException(nameof(protocol))), copy: false)

System.Net.WebClient (4)

System\Net\WebClient.cs (4)

510formHeaderBytes = Encoding.UTF8.GetBytes(formHeader); 613byte[] buffer = Encoding.ASCII.GetBytes(values.ToString()); 675byte[] requestData = Encoding.GetBytes(data); 1378byte[] requestData = Encoding.GetBytes(data);

System.Net.WebHeaderCollection (1)

System\Net\WebHeaderCollection.cs (1)

417return System.Text.Encoding.ASCII.GetBytes(tempString);

System.Private.CoreLib (29)

src\libraries\Common\src\Internal\VersionResilientHashCode.cs (1)

31byte[] src = Encoding.UTF8.GetBytes(name);

src\libraries\System.Private.CoreLib\src\Internal\Console.Unix.cs (2)

15byte[] bytes = Encoding.UTF8.GetBytes(s); 27byte[] bytes = Encoding.UTF8.GetBytes(s);

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventSource.cs (2)

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\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\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\Text\UTF8Encoding.Sealed.cs (1)

51return base.GetBytes(s!); // make the base method responsible for the null check

src\System\Reflection\Emit\CustomAttributeBuilder.cs (1)

354byte[] utf8Str = Encoding.UTF8.GetBytes(str);

System.Private.CoreLib.Generators (1)

EventSourceGenerator.Parser.cs (1)

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

System.Private.DataContractSerialization (5)

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

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

System\Runtime\Serialization\Json\JsonXmlDataContract.cs (1)

33MemoryStream memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(xmlContent));

System\Xml\ValueHandle.cs (1)

459return DataContractSerializer.Base64Encoding.GetBytes(XmlConverter.StripWhitespace(GetString()));

System\Xml\XmlConverter.cs (1)

364return DataContractSerializer.ValidatingUTF8.GetBytes(value);

System\Xml\XmlDictionaryString.cs (1)

78return _buffer ??= System.Text.Encoding.UTF8.GetBytes(_value);

System.Private.Xml (3)

System\Xml\Resolvers\XmlPreloadedResolver.cs (1)

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

System\Xml\Serialization\Compilation.cs (1)

430byte[] info = new UTF8Encoding(true).GetBytes(codecontent);

System\Xml\Serialization\Compiler.cs (1)

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

System.Reflection.Metadata (1)

System\Reflection\Metadata\Internal\StringHeap.cs (1)

215StringKind.Virtual => Encoding.UTF8.GetBytes(GetVirtualString(handle.GetVirtualIndex())),

System.Reflection.MetadataLoadContext (1)

System\Reflection\TypeLoading\General\Helpers.cs (1)

367public static byte[] ToUtf8(this string s) => Encoding.UTF8.GetBytes(s);

System.Security.Cryptography (3)

System\Security\Cryptography\PasswordDeriveBytes.cs (1)

58this((new UTF8Encoding(false)).GetBytes(strPassword), rgbSalt, strHashName, iterations, cspParams) { }

System\Security\Cryptography\Rfc2898DeriveBytes.cs (2)

59Encoding.UTF8.GetBytes(password ?? throw new ArgumentNullException(nameof(password))), 89byte[] passwordBytes = Encoding.UTF8.GetBytes(password);

System.Security.Cryptography.Xml (17)

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)

223inputStream = new MemoryStream(_encoding.GetBytes(idElem.OuterXml)); 715byte[] plainText = (content ? _encoding.GetBytes(inputElement.InnerXml) : _encoding.GetBytes(inputElement.OuterXml));

System\Security\Cryptography\Xml\ExcCanonicalXml.cs (1)

55return Encoding.UTF8.GetBytes(sb.ToString());

System\Security\Cryptography\Xml\XmlDsigBase64Transform.cs (1)

101byte[] buffer = Encoding.UTF8.GetBytes(sb.ToString());

System.ServiceModel.NetNamedPipe (1)

System\ServiceModel\Channels\PipeConnectionInitiator.cs (1)

357byte[] canonicalBytes = Encoding.UTF8.GetBytes(canonicalName);

System.Text.Json (2)

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

JsonSourceGenerator.Parser.cs (1)

1637byte[] utf8Json = Encoding.UTF8.GetBytes(effectiveJsonPropertyName);

System.Web.HttpUtility (3)

System\Web\HttpUtility.cs (2)

184public static byte[]? UrlEncodeUnicodeToBytes(string? str) => str == null ? null : Encoding.ASCII.GetBytes(UrlEncodeUnicode(str)); 212return UrlDecodeToBytes(e.GetBytes(str));

System\Web\Util\HttpEncoder.cs (1)

469byte[] bytes = e.GetBytes(str);

System.Windows.Forms (6)

System\Windows\Forms\Control.cs (1)

6500bytes = Encoding.Unicode.GetBytes(value);

System\Windows\Forms\Controls\DataGridView\DataGridView.Methods.cs (2)

8155byte[] sourceBytes = Encoding.Unicode.GetBytes(sbContent.ToString()); 8179sourceBytes = Encoding.Unicode.GetBytes(sbContent.ToString());

System\Windows\Forms\Controls\RichTextBox\RichTextBox.cs (2)

2826encodedBytes = Encoding.Unicode.GetBytes(str); 2831encodedBytes = (CodePagesEncodingProvider.Instance.GetEncoding(0) ?? Encoding.UTF8).GetBytes(str);

System\Windows\Forms\Controls\TextBox\TextBoxBase.cs (1)

1859byte[] bytes = e.GetBytes(str);

System.Windows.Forms.Design (1)

System\Windows\Forms\Design\Behavior\BehaviorService.cs (1)

776bytes = Encoding.Unicode.GetBytes(text);

System.Windows.Forms.Tests (16)

SerializableTypesTests.cs (1)

29byte[] bytes = Encoding.UTF8.GetBytes(payload);

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

System\Windows\Forms\WebBrowserTests.cs (2)

579using MemoryStream value = new(Encoding.UTF8.GetBytes(Html)); 4651byte[] data = Encoding.UTF8.GetBytes(html);

Templates.Blazor.Tests (1)

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

677bytePayload = Encoding.ASCII.GetBytes(AspNetHttpsOidFriendlyName);

Templates.Blazor.WebAssembly.Auth.Tests (1)

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

677bytePayload = Encoding.ASCII.GetBytes(AspNetHttpsOidFriendlyName);

Templates.Blazor.WebAssembly.Tests (1)

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

677bytePayload = Encoding.ASCII.GetBytes(AspNetHttpsOidFriendlyName);

Templates.Mvc.Tests (1)

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

677bytePayload = Encoding.ASCII.GetBytes(AspNetHttpsOidFriendlyName);

Templates.Tests (1)

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

677bytePayload = Encoding.ASCII.GetBytes(AspNetHttpsOidFriendlyName);

UIAutomationTypes (1)

src\Microsoft.DotNet.Wpf\src\Shared\MS\Win32\NativeMethodsCLR.cs (1)

2366byte[] bytes = Encoding.Default.GetBytes(s);

vbc (2)

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

VBCSCompiler (2)

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

WebSocketSample (1)

Program.cs (1)

37var bytes = Encoding.UTF8.GetBytes(line);