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\runtime\src\libraries\Common\src\System\Text\ConsoleEncoding.cs (1)

98public override byte[] GetBytes(string s)

System.Private.CoreLib (1)

src\runtime\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)

943 references to GetBytes

aspire (12)

Caching\DiskCache.cs (1)

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

Certificates\CertificateGeneration\CertificateManager.cs (1)

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

Certificates\CertificateGeneration\UnixCertificateManager.cs (1)

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

NuGet\BundleNuGetService.cs (1)

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

Projects\AppHostServerProject.cs (1)

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

Projects\DotNetBasedAppHostServerProject.cs (1)

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

Projects\GuestAppHostProject.cs (1)

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

Projects\PrebuiltAppHostServer.cs (1)

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

src\Shared\BackchannelConstants.cs (1)

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

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

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

Telemetry\MachineInformationProviderBase.cs (1)

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

Utils\ConfigurationHelper.cs (1)

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

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

AspireEventHubsExtensionsTests.cs (1)

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

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

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

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

AspireKeyVaultExtensionsTests.cs (1)

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

MockTransport.cs (1)

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

Aspire.Cli.Tests (2)

Agents\SigstoreNpmProvenanceCheckerTests.cs (1)

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

Caching\DiskCacheTests.cs (1)

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

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, fileMode: Unix.FileMode755, ct: ct);

ProducerConfigurationTests.cs (1)

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

Aspire.Dashboard (11)

Configuration\DashboardOptions.cs (8)

Extensions\JSInteropExtensions.cs (1)

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

Model\GenAI\GenAIMessageParsingHelper.cs (1)

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

Model\TextVisualizerViewModel.cs (1)

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

Aspire.Dashboard.Components.Tests (15)

Pages\TraceDetailsTests.cs (9)

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

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

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

Aspire.Dashboard.Tests (32)

Integration\McpServiceTests.cs (3)

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

Integration\OtlpHttpServiceTests.cs (2)

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

Model\TelemetryImportServiceTests.cs (11)

TelemetryRepositoryTests\MetricsTests.cs (2)

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

TelemetryRepositoryTests\TraceTests.cs (8)

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

Aspire.Hosting (13)

ApplicationModel\ReferenceExpression.cs (4)

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

Dashboard\ResourceServiceOptions.cs (1)

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

Dcp\DcpExecutor.cs (1)

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

Dcp\DcpHost.cs (1)

367hash.AddBytes(Encoding.UTF8.GetBytes(category));

Dcp\DcpLogParser.cs (1)

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

DistributedApplicationBuilder.cs (2)

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

src\Shared\BackchannelConstants.cs (1)

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

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

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

Utils\ImageNameGenerator.cs (1)

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

Aspire.Hosting.Azure (1)

Provisioning\BicepUtilities.cs (1)

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

Aspire.Hosting.Azure.Tests (14)

AzureDeployerTests.cs (1)

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

AzureEventHubsExtensionsTests.cs (1)

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

DefaultUserPrincipalProviderTests.cs (9)

ProvisioningTestHelpers.cs (3)

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

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)

84var body = Encoding.UTF8.GetBytes(message); 149var body = Encoding.UTF8.GetBytes(message);

Aspire.Hosting.Tests (23)

AspireStoreTests.cs (2)

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

Dcp\DcpExecutorTests.cs (7)

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

Dcp\DcpLogParserTests.cs (11)

Dcp\TestKubernetesService.cs (1)

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

ProjectResourceTests.cs (1)

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

Utils\VolumeNameGeneratorTests.cs (1)

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

Aspire.Microsoft.Extensions.Configuration.AzureAppConfiguration.Tests (2)

AspireAppConfigurationExtensionsTest.cs (1)

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

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

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

Aspire.RabbitMQ.Client.Tests (1)

AspireRabbitMQExtensionsTests.cs (1)

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

Aspire.RabbitMQ.Client.v6.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)

377byte[] 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)));

ConfigurationSchemaGenerator.Tests (1)

GeneratorTests.cs (1)

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

csc (2)

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

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

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

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

dotnet (6)

Commands\Run\VirtualProjectBuildingCommand.cs (1)

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

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

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

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

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

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

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

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

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

dotnet-dev-certs (2)

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

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

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

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

dotnet-Microsoft.XmlSerializer.Generator (1)

Sgen.cs (1)

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

dotnet-razorpagegenerator (1)

Program.cs (1)

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

dotnet-sourcelink (2)

AuthenticationHeaderProvider.cs (1)

28=> new("Basic", Convert.ToBase64String(_encoding.GetBytes($"{_username}:{_password}")));

Program.cs (1)

534parameter: Convert.ToBase64String(encoding.GetBytes($"{username}:{password}"))),

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)

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

EventSourceGenerator (1)

EventSourceGenerator.Parser.cs (1)

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

GenerateDocumentationAndConfigFiles (1)

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

255result = s_lazyUtf8.GetBytes(s);

ILAssembler (2)

VTableExportPEBuilder.cs (2)

549byte[] nameBytes = Encoding.ASCII.GetBytes(export.Name); 555byte[] dllNameBytes = Encoding.ASCII.GetBytes(_dllName);

ilc (1)

Program.cs (1)

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

ILCompiler.Compiler (19)

Compiler\CompilerTypeSystemContext.InterfaceThunks.cs (1)

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

Compiler\Dataflow\AttributeDataFlow.cs (1)

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

Compiler\DependencyAnalysis\CustomAttributeBasedDependencyAlgorithm.cs (1)

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

Compiler\DependencyAnalysis\NodeFactory.cs (3)

1350var type = _context.SystemModule.GetKnownType(Encoding.UTF8.GetBytes(entry[0]), Encoding.UTF8.GetBytes(entry[1])); 1351var method = type.GetKnownMethod(Encoding.UTF8.GetBytes(entry[2]), null);

Compiler\DependencyAnalysis\StackTraceDocumentsNode.cs (1)

82bw.Write(Encoding.UTF8.GetBytes(_documents[i]));

Compiler\ExternSymbolMappedField.cs (1)

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

Compiler\Logging\DocumentationSignatureParser.cs (2)

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

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

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

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

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

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

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

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

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

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

29_value = Encoding.UTF8.GetBytes(s);

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

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

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

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

ILCompiler.MetadataTransform (1)

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

206byte[] bytes = s_stringEncoding.GetBytes(s);

ILCompiler.ReadyToRun (16)

Compiler\CallChainProfile.cs (1)

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

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

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

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

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

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

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

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

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

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

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

Compiler\ReadyToRunExternalTypeMapNode.cs (1)

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

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

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

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

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

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

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

206byte[] bytes = s_stringEncoding.GetBytes(s);

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

29_value = Encoding.UTF8.GetBytes(s);

ILCompiler.TypeSystem (6)

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

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

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

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

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

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

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

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

illink (1)

Linker\CustomSymbolWriter.cs (1)

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

Infrastructure.Common (2)

SafeKeychainHandle.cs (2)

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

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

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

OpenIdConnectPostConfigureOptions.cs (1)

119return Encoding.UTF8.GetBytes(model);

Microsoft.AspNetCore.Authentication.Twitter (2)

TwitterHandler.cs (2)

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

Microsoft.AspNetCore.Components (2)

PersistentState\PersistentServicesRegistry.cs (1)

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

PersistentState\PersistentStateValueProviderKeyResolver.cs (1)

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

Microsoft.AspNetCore.Components.Endpoints (3)

Rendering\EndpointHtmlRenderer.Streaming.cs (2)

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

Rendering\TypeNameHash.cs (1)

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

Microsoft.AspNetCore.Components.Server (1)

Circuits\CircuitPersistenceManager.cs (1)

84var rootComponentsBytes = Encoding.UTF8.GetBytes(rootComponents);

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

TargetPickerUi.cs (2)

54var bytes = Encoding.UTF8.GetBytes(msg); 55var 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.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.KeyDerivation (1)

PBKDF2\ManagedPbkdf2Provider.cs (1)

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

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

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

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

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

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

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\aspnetcore\src\Grpc\JsonTranscoding\src\Shared\AuthContextHelpers.cs (1)

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

Microsoft.AspNetCore.Http.Extensions (1)

SessionExtensions.cs (1)

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

Microsoft.AspNetCore.Identity (4)

IdentityApiEndpointRouteBuilderExtensions.cs (2)

215code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code)); 400code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));

PasskeyHandler.cs (1)

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

Passkeys\BufferSource.cs (1)

40var buffer = Encoding.UTF8.GetBytes(value);

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

UrlActions\CustomResponseAction.cs (1)

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

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

Core\IISHttpContext.cs (4)

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

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

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)

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

Internal\Infrastructure\HttpUtilities.cs (1)

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

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

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

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

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

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

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

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

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

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

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

Microsoft.AspNetCore.Session (2)

CookieProtection.cs (1)

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

EncodedKey.cs (1)

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

Microsoft.AspNetCore.SignalR.Core (1)

Internal\Utf8HashLookup.cs (1)

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

Microsoft.AspNetCore.StaticFiles (1)

HtmlDirectoryFormatter.cs (1)

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

Microsoft.AspNetCore.Watch.BrowserRefresh (2)

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

75return Encoding.UTF8.GetBytes(script);

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

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

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

Evaluation\IntrinsicFunctions.cs (2)

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

Logging\BinaryLogger\ProjectImportsCollector.cs (1)

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

Microsoft.Build.Framework (4)

BackEnd\ServerNodeHandshake.cs (1)

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

EncodingUtilities.cs (1)

196var unicodeBytes = unicodeEncoding.GetBytes(stringToEncode);

Telemetry\CrashTelemetry.cs (1)

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

Telemetry\TelemetryDataUtils.cs (1)

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

Microsoft.Build.Tasks.CodeAnalysis (2)

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

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

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

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

Microsoft.Build.Tasks.Core (3)

FileIO\WriteLinesToFile.cs (1)

318byte[] newContentBytes = encoding.GetBytes(contentsAsString);

ManifestUtil\mansign2.cs (1)

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

ResourceHandling\MSBuildResXReader.cs (1)

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

Microsoft.CodeAnalysis (5)

CommandLine\CommonCompiler.cs (1)

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

CryptographicHashProvider.cs (1)

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

DiaSymReader\Writer\SymUnmanagedWriterImpl.cs (1)

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

InternalUtilities\StringExtensions.cs (1)

255result = s_lazyUtf8.GetBytes(s);

PEWriter\MetadataWriter.DynamicAnalysis.cs (1)

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

Microsoft.CodeAnalysis.Analyzers (1)

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

255result = s_lazyUtf8.GetBytes(s);

Microsoft.CodeAnalysis.AnalyzerUtilities (1)

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

255result = s_lazyUtf8.GetBytes(s);

Microsoft.CodeAnalysis.CodeStyle (1)

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

255result = s_lazyUtf8.GetBytes(s);

Microsoft.CodeAnalysis.CSharp (1)

Symbols\FileIdentifier.cs (1)

47var encodedFilePath = s_encoding.GetBytes(_filePath);

Microsoft.CodeAnalysis.CSharp.Workspaces (1)

SyncedSource\FileBasedPrograms\Sha256Hasher.cs (1)

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

Microsoft.CodeAnalysis.Extensions.Package (1)

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

255result = s_lazyUtf8.GetBytes(s);

Microsoft.CodeAnalysis.Razor.Compiler (1)

Language\InMemoryFileContent.cs (1)

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

Microsoft.CodeAnalysis.ResxSourceGenerator (1)

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

255result = s_lazyUtf8.GetBytes(s);

Microsoft.CodeAnalysis.VisualBasic (1)

Symbols\AnonymousTypes\CRC32.vb (1)

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

Microsoft.CodeAnalysis.Workspaces (2)

Log\AnalyzerNameForTelemetry.cs (1)

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

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

255result = s_lazyUtf8.GetBytes(s);

Microsoft.CodeAnalysis.Workspaces.MSBuild (1)

Rpc\RpcClient.cs (1)

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

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

AbstractBuildHost.cs (1)

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

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.Diagnostics.NETCore.Client (3)

BinaryWriterExtensions.cs (1)

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

DiagnosticsIpc\IpcAdvertise.cs (1)

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

DiagnosticsIpc\IpcHeader.cs (1)

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

Microsoft.DiaSymReader (1)

Writer\SymUnmanagedWriterImpl.cs (1)

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

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)

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

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

src\ArWriter.cs (7)

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

src\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.Templating (1)

GenerateFileFromTemplate.cs (1)

84byte[] resultBytes = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false).GetBytes(result);

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); 143byte[] nameBytes = Encoding.Unicode.GetBytes(name);

Microsoft.DotNet.Cli.Utils (1)

Uuid.cs (1)

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

Microsoft.DotNet.HotReload.Watch (2)

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

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

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

86var bytes = Encoding.UTF8.GetBytes(value);

Microsoft.DotNet.ProjectTools (1)

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

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

Microsoft.DotNet.TemplateLocator (2)

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

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

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

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

Microsoft.Extensions.AI.Abstractions (1)

Contents\DataUriParser.cs (1)

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

Microsoft.Extensions.AI.Abstractions.Tests (6)

Contents\DataContentTests.cs (6)

319byte[] testData = Encoding.UTF8.GetBytes("{\"key\": \"value\"}"); 483byte[] testData = Encoding.UTF8.GetBytes("{}"); 510byte[] testData = Encoding.UTF8.GetBytes("{}"); 542byte[] testData = Encoding.UTF8.GetBytes("{}"); 571byte[] testData = Encoding.UTF8.GetBytes("{}"); 717byte[] testData = Encoding.UTF8.GetBytes("<html></html>");

Microsoft.Extensions.AI.Evaluation.Reporting.Tests (2)

ResponseCacheTester.cs (2)

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

Microsoft.Extensions.AI.Integration.Tests (2)

PromptBasedFunctionCallingChatClient.cs (1)

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

VerbatimHttpHandler.cs (1)

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

Microsoft.Extensions.AI.OpenAI (3)

OpenAIAssistantsChatClient.cs (1)

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

OpenAIResponsesChatClient.cs (2)

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

Microsoft.Extensions.AI.OpenAI.Tests (6)

OpenAIHostedFileClientIntegrationTests.cs (5)

33byte[] contentBytes = Encoding.UTF8.GetBytes(content); 202byte[] contentBytes = Encoding.UTF8.GetBytes(content); 231byte[] contentBytes = Encoding.UTF8.GetBytes(content); 298byte[] contentBytes = Encoding.UTF8.GetBytes(content2); 416using var uploadStream = new MemoryStream(Encoding.UTF8.GetBytes(csvContent));

OpenAIResponseClientTests.cs (1)

5174var pdfData = Encoding.UTF8.GetBytes("pdfdata");

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

RedisCache.cs (1)

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

Microsoft.Extensions.DataIngestion.Tests (1)

Readers\MarkdownReaderTests.cs (1)

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

Microsoft.Extensions.Diagnostics.ResourceMonitoring.Tests (3)

Linux\OSFileSystemTests.cs (3)

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

Microsoft.Extensions.DotNetDeltaApplier (1)

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

86var bytes = Encoding.UTF8.GetBytes(value);

Microsoft.Extensions.Hosting.Systemd (1)

ServiceState.cs (1)

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

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

Logging\HttpClientLoggerTest.cs (2)

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

Logging\HttpClientLoggingExtensionsTest.cs (1)

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

Logging\HttpResponseBodyReaderTest.cs (3)

155Content = new StreamContent(new NotSeekableStream(new(Encoding.UTF8.GetBytes(bigContent)))) 182Content = new StreamContent(new NotSeekableStream(new(Encoding.UTF8.GetBytes(bigContent)))) 291var memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(content));

Microsoft.Extensions.Identity.Core (3)

Rfc6238AuthenticationService.cs (2)

104var modifierBytes = modifier is not null ? _encoding.GetBytes(modifier) : null; 126var modifierBytes = modifier is not null ? _encoding.GetBytes(modifier) : null;

UserManager.cs (1)

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

Microsoft.Extensions.ServiceDiscovery.Dns.Tests (1)

Resolver\LoopbackDnsServer.cs (1)

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

Microsoft.JSInterop (1)

Infrastructure\DotNetDispatcher.cs (1)

308var utf8JsonBytes = Encoding.UTF8.GetBytes(arguments);

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

DoubleArrayTrieTest.cs (2)

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

SentencePieceTests.cs (1)

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

UnigramTests.cs (41)

Microsoft.NET.Build.Containers (19)

AuthHandshakeMessageHandler.cs (2)

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

DigestUtils.cs (1)

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

ImageBuilder.cs (1)

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

LocalDaemons\ContainerArchive.cs (7)

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

LocalDaemons\DockerCli.cs (7)

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

Registry\Registry.cs (1)

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

Microsoft.NET.Build.Tasks (3)

AllowEmptyTelemetry.cs (1)

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

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

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

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

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

Microsoft.NET.HostModel (6)

AppHost\HostWriter.cs (4)

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

ComHost\ComHost.cs (1)

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

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

307var identifierBytes = Encoding.UTF8.GetBytes(_identifier);

Microsoft.NET.Sdk.BlazorWebAssembly.Tasks (4)

BrotliCompress.cs (1)

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

GenerateServiceWorkerAssetsManifest.cs (1)

72var bytes = sha.ComputeHash(Encoding.UTF8.GetBytes(combinedHash));

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

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

Microsoft.NET.Sdk.Publish.Tasks (2)

Kudu\KuduConnect.cs (1)

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

Tasks\Http\HttpClientExtensions.cs (1)

286byte[] plainAuthBytes = Encoding.ASCII.GetBytes(plainAuth);

Microsoft.NET.Sdk.Razor.Tasks (3)

EncodeRazorInputItem.cs (1)

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

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

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

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

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

Microsoft.NET.Sdk.StaticWebAssets.Tasks (6)

OverrideHtmlAssetPlaceholders.cs (1)

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

ScopedCss\ComputeCssScope.cs (1)

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

ServiceWorker\GenerateServiceWorkerAssetsManifest.cs (2)

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

Utils\FileHasher.cs (2)

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

Microsoft.NET.Sdk.WorkloadManifestReader (2)

SdkDirectoryWorkloadManifestProvider.cs (1)

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

SdkDirectoryWorkloadManifestProvider.GlobalJsonReader.cs (1)

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

Microsoft.Private.Windows.Core (3)

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

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

Microsoft.TemplateEngine.Core (108)

Expressions\Cpp\CppStyleEvaluatorDefinition.cs (25)

Expressions\Cpp2\Cpp2StyleEvaluatorDefinition.cs (27)

Expressions\MSBuild\MSBuildStyleEvaluatorDefinition.cs (18)

Expressions\ScopeBuilder.cs (2)

56trie.AddToken(processor.Encoding.GetBytes(string.Format(processor.Config.VariableFormatString, variable.Key))); 182byte[] data = _processor.Encoding.GetBytes(valText);

Expressions\Shared\SharedEvaluatorDefinition.cs (2)

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

Expressions\VisualBasic\VisualBasicStyleEvaluatorDefintion.cs (28)

Operations\ExpandVariables.cs (1)

54byte[] outputBytes = processor.Encoding.GetBytes(output);

Operations\PhasedOperation.cs (1)

47Replacement = c.Replacement != null ? encoding.GetBytes(c.Replacement) : tokens[existingMatchToken].Value,

Operations\Replacement.cs (1)

30byte[] replaceWith = encoding.GetBytes(_replaceWith);

TokenConfig.cs (3)

47byte[] pre = string.IsNullOrEmpty(After) ? [] : encoding.GetBytes(After); 48byte[] post = string.IsNullOrEmpty(Before) ? [] : encoding.GetBytes(Before); 49byte[] core = string.IsNullOrEmpty(Value) ? [] : encoding.GetBytes(Value);

Microsoft.TemplateEngine.Orchestrator.RunnableProjects (1)

FileRenameGenerator.cs (1)

90using MemoryStream source = new(Encoding.UTF8.GetBytes(sourceFilename));

Microsoft.TestPlatform.AdapterUtilities (1)

TestIdProvider.cs (1)

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

Microsoft.TestPlatform.Extensions.BlameDataCollector (1)

BlameCollector.cs (1)

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

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

TestProperty\CustomKeyValueConverter.cs (1)

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

TestProperty\CustomStringArrayConverter.cs (1)

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

Utilities\EqtHash.cs (1)

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

Mono.Cecil (8)

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

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

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

402 WriteBytes (Encoding.UTF8.GetBytes (@string));

Mono.Cecil\AssemblyWriter.cs (5)

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

Mono.Cecil.Pdb (1)

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

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

NuGet.Build.Tasks.Pack (1)

GetPackOutputItemsTask.cs (1)

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

NuGet.Common (1)

ConcurrencyUtilities.cs (1)

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

NuGet.Configuration (2)

Utility\EncryptionUtility.cs (2)

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

NuGet.PackageManagement (1)

Utility\StreamUtility.cs (1)

24return new MemoryStream(encoding.GetBytes(content));

NuGet.Packaging (5)

PackageCreation\Authoring\PackageBuilder.cs (1)

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

Signing\Archive\SignedPackageArchiveIOUtility.cs (2)

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

Signing\Archive\SignedPackageArchiveUtility.cs (1)

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

Signing\Cms\HeapBlockRetainer.cs (1)

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

NuGet.ProjectModel (120)

DependencyGraphSpec.cs (2)

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

JsonPackageSpecReader.cs (1)

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

JsonPackageSpecReader.Utf8JsonStreamReader.cs (74)

LockFile\LockFileFormat.cs (1)

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

LockFile\Utf8JsonStreamIAssetsLogMessageConverter.cs (11)

LockFile\Utf8JsonStreamLockFileConverter.cs (8)

LockFile\Utf8JsonStreamLockFileLibraryConverter.cs (7)

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

LockFile\Utf8JsonStreamLockFileTargetLibraryConverter.cs (16)

NuGet.Protocol (1)

Utility\CachingUtility.cs (1)

31hash = sha.ComputeHash(Encoding.UTF8.GetBytes(value));

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)

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

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

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

RepoTasks (3)

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

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

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

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

Uuid.cs (1)

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

Roslyn.Diagnostics.Analyzers (1)

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

255result = s_lazyUtf8.GetBytes(s);

rzc (3)

PipeName.cs (1)

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

RazorSourceGeneratorHost.cs (1)

61["build_metadata.AdditionalFiles.TargetPath"] = Convert.ToBase64String(Encoding.UTF8.GetBytes(file.TargetPath)),

ServerProtocol\ServerLogger.cs (1)

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

sdk-tasks (1)

GenerateGuidFromName.cs (1)

20var nameBytes = System.Text.Encoding.UTF8.GetBytes(name ?? string.Empty);

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\runtime\src\libraries\Common\src\System\Text\ConsoleEncoding.cs (1)

100return _encoding.GetBytes(s);

System\ConsolePal.Unix.cs (1)

1139data = 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.DirectoryServices.Protocols (8)

System\DirectoryServices\Protocols\common\BerConverter.cs (2)

118tempValue = utf8Encoder.GetBytes((string)value[valueCount]); 178tempValues[i] = utf8Encoder.GetBytes(s);

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

76results[i] = s_encoder.GetBytes((string)List[i]);

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

946_target = s_utf8Encoding.GetBytes(target);

System\DirectoryServices\Protocols\ldap\LdapConnection.cs (4)

593byteArray = encoder.GetBytes(str); 598byteArray = encoder.GetBytes(uri.ToString()); 1299byteArray = encoder.GetBytes((string)modAttribute[j]); 1303byteArray = encoder.GetBytes(((Uri)modAttribute[j]).ToString());

System.IO.Compression (2)

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

205return encoding.GetBytes(text); 208byte[] bytes = 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 (15)

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

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

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

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

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

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

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

25private static readonly byte[] CrLfBytes = HttpRuleParser.DefaultHttpEncoding.GetBytes("\r\n"); 26private static readonly byte[] DashDashBytes = HttpRuleParser.DefaultHttpEncoding.GetBytes("--"); 49byte[] boundaryBytes = HttpRuleParser.DefaultHttpEncoding.GetBytes(boundary);

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)

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

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

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

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

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

System.Net.Http.WinHttpHandler (1)

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

212byte[] chunkSize = Encoding.UTF8.GetBytes($"{count:x}\r\n");

System.Net.HttpListener (6)

System\Net\HttpListenerRequestUriBuilder.cs (2)

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

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

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

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

273byte[] statusDescriptionBytes = Encoding.Latin1.GetBytes(StatusDescription);

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

132Encoding.ASCII.GetBytes($"{size:x}\r\n{(final ? "\r\n" : "")}");

System\Net\WebSockets\HttpWebSocket.cs (1)

22byte[] toHash = Encoding.UTF8.GetBytes(acceptString);

System.Net.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)

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

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

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

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

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

System.Net.Requests (1)

System\Net\CommandStream.cs (1)

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

System.Net.Security (3)

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

57private static readonly byte[] s_workstation = Encoding.Unicode.GetBytes(Environment.MachineName); 436byte[] 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)

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

System.Private.CoreLib (9)

src\runtime\src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\ManifestBuilder.cs (1)

339return (str != "") ? Encoding.UTF8.GetBytes(str) : [];

src\runtime\src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\TraceLogging\TraceLoggingEventSource.cs (2)

804metaData.AddRange(Encoding.UTF8.GetBytes(value.Substring(1))); 824metaData.AddRange(Encoding.UTF8.GetBytes(value));

src\runtime\src\libraries\System.Private.CoreLib\src\System\Globalization\DateTimeFormatInfo.cs (5)

367Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(amDesignatorUtf8 ??= Encoding.UTF8.GetBytes(AMDesignator)); 616Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(dateSeparatorUtf8 ??= Encoding.UTF8.GetBytes(DateSeparator)); 819Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(pmDesignatorUtf8 ??= Encoding.UTF8.GetBytes(PMDesignator)); 1001Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(timeSeparatorUtf8 ??= Encoding.UTF8.GetBytes(TimeSeparator)); 1701Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_decimalSeparatorUtf8 ??= Encoding.UTF8.GetBytes(DecimalSeparator));

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

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

System.Private.DataContractSerialization (4)

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

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

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

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

253 fixed (byte* lpMultiByteStrLocal = lpMultiByteStr is object ? global::System.Text.Encoding.Default.GetBytes(lpMultiByteStr) : null) 303 fixed (byte* lpDefaultCharLocal = lpDefaultChar is object ? global::System.Text.Encoding.Default.GetBytes(lpDefaultChar) : null) 318 fixed (byte* lpDefaultCharLocal = lpDefaultChar is object ? global::System.Text.Encoding.Default.GetBytes(lpDefaultChar) : null)

System.Private.Xml (3)

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

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

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

431byte[] 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)

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

System.Runtime.Numerics (1)

System\Number.Polyfill.cs (1)

125return Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(Encoding.UTF8.GetBytes(value));

System.Security.Cryptography (6)

System\Security\Cryptography\BasicSymmetricCipherLiteNCrypt.cs (3)

19new CngProperty(KeyPropertyName.ChainingMode, Encoding.Unicode.GetBytes(Cng.BCRYPT_CHAIN_MODE_ECB + "\0"), CngPropertyOptions.None); 21new CngProperty(KeyPropertyName.ChainingMode, Encoding.Unicode.GetBytes(Cng.BCRYPT_CHAIN_MODE_CBC + "\0"), CngPropertyOptions.None); 23new CngProperty(KeyPropertyName.ChainingMode, Encoding.Unicode.GetBytes(Cng.BCRYPT_CHAIN_MODE_CFB + "\0"), CngPropertyOptions.None);

System\Security\Cryptography\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)

243inputStream = new MemoryStream(_encoding.GetBytes(idElem.OuterXml)); 740byte[] 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.Security.Principal.Windows (2)

System\Security\Principal\WindowsIdentity.cs (2)

154byte[] upnBytes = Encoding.Unicode.GetBytes(sUserPrincipalName); 246byte[] asciiPackageName = Encoding.ASCII.GetBytes(packageName);

System.ServiceModel.Http (1)

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

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

System.ServiceModel.NetNamedPipe (1)

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

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

System.ServiceModel.Primitives (10)

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

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

Internals\System\Xml\XmlMtomReader.cs (1)

1324_binHexStream = new MemoryStream(new BinHexEncoding().GetBytes(Value));

System\IdentityModel\CanonicalFormWriter.cs (1)

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

System\IdentityModel\Tokens\WSSecurityJan2004.cs (1)

306bytes = new UTF8Encoding().GetBytes(reader.ReadContentAsString());

System\ServiceModel\Security\Tokens\DerivedKeySecurityToken.cs (1)

201(_label != null ? Encoding.UTF8.GetBytes(_label) : s_DefaultLabel), _nonce, Length * 8,

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

163_fragment1 = encoding.GetBytes(Xml1); 164_fragment2 = encoding.GetBytes(Xml2); 165_fragment3 = encoding.GetBytes(Xml3); 166_fragment4 = encoding.GetBytes(Xml4);

System.Text.Json (4)

System\Text\Json\Serialization\Converters\FSharp\FSharpTypeConverterFactory.cs (1)

95byte[] utf8EncodedName = System.Text.Encoding.UTF8.GetBytes(typeDiscriminatorPropertyName);

System\Text\Json\Serialization\JsonUnionTypeStructuralClassifier.cs (1)

709public byte[] NameAsUtf8Bytes { get; } = Encoding.UTF8.GetBytes(name);

System\Text\Json\Serialization\Metadata\JsonPropertyInfo.cs (1)

485NameAsUtf8Bytes = Encoding.UTF8.GetBytes(Name);

System\Text\Json\Serialization\Metadata\PolymorphicTypeResolver.cs (1)

83byte[] utf8EncodedName = Encoding.UTF8.GetBytes(propertyName);

System.Text.Json.SourceGeneration (1)

JsonSourceGenerator.Parser.cs (1)

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

System.Text.RegularExpressions.Generator (1)

RegexGenerator.Emitter.cs (1)

5578return $"{prefix}{ToHexStringNoDashes(sha.ComputeHash(Encoding.UTF8.GetBytes(toEncode)))}";

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)

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

System.Windows.Forms (6)

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

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

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

8152byte[] sourceBytes = Encoding.Unicode.GetBytes(sbContent.ToString()); 8176sourceBytes = Encoding.Unicode.GetBytes(sbContent.ToString());

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

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

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

2282byte[] 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.Primitives (7)

_generated\236\Windows.Win32.IRichEditOle.g.cs (3)

252 fixed (byte* lpstrUserTypeNewLocal = lpstrUserTypeNew is object ? global::System.Text.Encoding.Default.GetBytes(lpstrUserTypeNew) : null) 362 fixed (byte* lpstrContainerObjLocal = lpstrContainerObj is object ? global::System.Text.Encoding.Default.GetBytes(lpstrContainerObj) : null) 364 fixed (byte* lpstrContainerAppLocal = lpstrContainerApp is object ? global::System.Text.Encoding.Default.GetBytes(lpstrContainerApp) : null)

_generated\418\Windows.Win32.PInvoke.KERNEL32.dll.g.cs (1)

511 fixed (byte* lpProcNameLocal = lpProcName is object ? global::System.Text.Encoding.Default.GetBytes(lpProcName) : null)

_generated\593\Windows.Win32.UI_Controls_RichEdit_IRichEditOle_Extensions.g.cs (3)

46 fixed (byte* lpstrUserTypeNewLocal = lpstrUserTypeNew is object ? global::System.Text.Encoding.Default.GetBytes(lpstrUserTypeNew) : null) 72 fixed (byte* lpstrContainerObjLocal = lpstrContainerObj is object ? global::System.Text.Encoding.Default.GetBytes(lpstrContainerObj) : null) 74 fixed (byte* lpstrContainerAppLocal = lpstrContainerApp is object ? global::System.Text.Encoding.Default.GetBytes(lpstrContainerApp) : null)

UIAutomationTypes (1)

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

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

vbc (2)

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

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

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

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

VBCSCompiler (3)

src\roslyn\src\Compilers\Server\VBCSCompiler\CompilationCache.cs (1)

123var bytes = SHA256.HashData(Encoding.UTF8.GetBytes(deterministicKey));

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

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

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

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