ToArray

ConformanceTests.cs (1)

117body: "hello world"u8.ToArray());

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

126body: "hello world"u8.ToArray());

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

27Name = name.ToArray(); 28Value = value.ToArray();

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

27Name = name.ToArray(); 28Value = value.ToArray();

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

27Name = name.ToArray(); 28Value = value.ToArray();

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

27Name = name.ToArray(); 28Value = value.ToArray();

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

27Name = name.ToArray(); 28Value = value.ToArray();

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

27Name = name.ToArray(); 28Value = value.ToArray();

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

27Name = name.ToArray(); 28Value = value.ToArray();

BadHttpRequestTests.cs (2)

266await client.Stream.WriteAsync(Core.Internal.Http2.Http2Connection.ClientPreface.ToArray()).DefaultTimeout(); 270Assert.Equal(Http1Connection.Http2GoAwayHttp11RequiredBytes.ToArray(), data);

Http2\Http2RequestTests.cs (1)

77var tags = measurement.Tags.ToArray();

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

1113return span.ToArray();

Managed\ManagedAuthenticatedEncryptor.cs (1)

512validationAlgorithm.Key = validationSubkeyArray ?? validationSubkey.ToArray();

UnaryServerCallHandlerTests.cs (2)

807httpContext.Request.Body = new MemoryStream("{}"u8.ToArray()); 1229httpContext.Request.Body = new MemoryStream("null"u8.ToArray());

HostFilteringMiddleware.cs (1)

25).ToArray();

Internal\ParsingHelpers.cs (1)

35string[] result = strings.AsSpan().ToArray();

Internal\ServerSentEventsTransport.cs (1)

139var parser = SseParser.Create(stream, (eventType, bytes) => bytes.ToArray());

RequestDelegateFactoryTests.cs (1)

903Span<byte> Method2() => "hello world"u8.ToArray();

Utf8ContentHttpResult.cs (1)

24ResponseContent = utf8Content.ToArray();

ResultsTests.cs (2)

1610var content = "test content"u8.ToArray(); 1626var content = "test content"u8.ToArray();

ServerSentEventsResultTests.cs (1)

291var bytes = "event1"u8.ToArray();

TypedResultsTests.cs (2)

1389var content = "test content"u8.ToArray(); 1405var content = "test content"u8.ToArray();

Utf8ContentResultTests.cs (3)

21var data = """{ "name" : "Hello" }"""u8.ToArray(); 34var data = "Hello"u8.ToArray(); 52var data = "Hello"u8.ToArray();

HttpLoggingMiddlewareTests.cs (2)

1776var request = new HttpRequestMessage(HttpMethod.Get, "/attr_restrictedsize") { Content = new ReadOnlyMemoryContent("from request"u8.ToArray()) }; 1866var request = new HttpRequestMessage(HttpMethod.Get, "/ext_restrictedsize") { Content = new ReadOnlyMemoryContent("from request"u8.ToArray()) };

Passkeys\CredentialKeyPair.cs (2)

75return _rsa.SignData(data.ToArray(), hashAlgorithm, padding); 86return _ecdsa.SignData(data.ToArray(), hashAlgorithm, DSASignatureFormat.Rfc3279DerSequence);

MemoryOutputCacheStoreTests.cs (10)

15var value = "abc"u8.ToArray(); 30var value = "abc"u8.ToArray(); 45var value = "abc"u8.ToArray(); 66var value = "abc"u8.ToArray(); 94var value = "abc"u8.ToArray(); 114var value = "abc"u8.ToArray(); 130var value = "abc"u8.ToArray(); 161var value = "abc"u8.ToArray(); 206var value = "abc"u8.ToArray(); 242var value = "abc"u8.ToArray();

OutputCacheEntryFormatterTests.cs (2)

45var bodySegment1 = "lorem"u8.ToArray(); 46var bodySegment2 = "こんにちは"u8.ToArray();

EndpointRoutingMiddlewareFormOptionsTest.cs (1)

104httpContext.Request.Body = new MemoryStream("foo=bar"u8.ToArray());

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

27Name = name.ToArray(); 28Value = value.ToArray();

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

27Name = name.ToArray(); 28Value = value.ToArray();

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

27Name = name.ToArray(); 28Value = value.ToArray();

InternalUtilities\LittleEndianReader.cs (1)

60var result = ReadBytes(byteCount).ToArray();

PEWriter\MetadataWriter.cs (1)

465_pseudoSymbolTokenToReferenceMap = referencesInIL.ToArray();

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

972TSource[] chunk = new ReadOnlySpan<TSource>(source, index, Math.Min(size, source.Length - index)).ToArray();

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

972TSource[] chunk = new ReadOnlySpan<TSource>(source, index, Math.Min(size, source.Length - index)).ToArray();

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

972TSource[] chunk = new ReadOnlySpan<TSource>(source, index, Math.Min(size, source.Length - index)).ToArray();

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

972TSource[] chunk = new ReadOnlySpan<TSource>(source, index, Math.Min(size, source.Length - index)).ToArray();

Extensions\IEnumerableExtensions.cs (1)

972TSource[] chunk = new ReadOnlySpan<TSource>(source, index, Math.Min(size, source.Length - index)).ToArray();

CSharpTestSource.cs (1)

96return source.ToArray();

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

972TSource[] chunk = new ReadOnlySpan<TSource>(source, index, Math.Min(size, source.Length - index)).ToArray();

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

972TSource[] chunk = new ReadOnlySpan<TSource>(source, index, Math.Min(size, source.Length - index)).ToArray();

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

972TSource[] chunk = new ReadOnlySpan<TSource>(source, index, Math.Min(size, source.Length - index)).ToArray();

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

972TSource[] chunk = new ReadOnlySpan<TSource>(source, index, Math.Min(size, source.Length - index)).ToArray();

RoundTripUtil.cs (2)

119rebuildPdbBytes = new ReadOnlySpan<byte>(rebuildPdbReader.MetadataPointer, rebuildPdbReader.MetadataLength).ToArray().ToImmutableArray(); 146return new EmitInfo(originalBytes, originalReader, pdbSpan.ToArray().ToImmutableArray(), originalPdbReader);

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

972TSource[] chunk = new ReadOnlySpan<TSource>(source, index, Math.Min(size, source.Length - index)).ToArray();

Assert\AssertEx.cs (3)

165Equal<T>(expected.ToArray(), actual); 815message.AppendLine(DiffUtil.DiffReport(expected.ToArray(), actual.ToArray(), itemSeparator, comparer, itemInspector));

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

972TSource[] chunk = new ReadOnlySpan<TSource>(source, index, Math.Min(size, source.Length - index)).ToArray();

Text\SourceTextTests.cs (1)

124var bytesNoBOM = "Hello, World!"u8.ToArray();

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

60var result = ReadBytes(byteCount).ToArray();

src\CpioWriter.cs (2)

21stream.Write("070701"u8.ToArray()); 38stream.Write("00000000"u8.ToArray()); // Check field

ChatCompletion\ChatResponseUpdateTests.cs (2)

124new DataContent("data"u8.ToArray(), "text/plain"), 152Assert.Equal("data"u8.ToArray(), ((DataContent)result.Contents[3]).Data.ToArray());

Common\NGram.cs (1)

20: this(values.ToArray())

src\Shared\ServerSentEvents\SseFormatter.cs (1)

21private static readonly byte[] _newLine = "\n"u8.ToArray();

BufferReleaseTests.cs (2)

134cache.BackendCache.Set(key, new ReadOnlySpan<byte>(arr, 0, bytes).ToArray()); 197cache.BackendCache.Set(key, new ReadOnlySpan<byte>(arr, 0, bytes).ToArray());

SerializerTests.cs (3)

32var value = "test value"u8.ToArray(); 294return Encoding.UTF8.GetString(value.ToArray()); 300return BitConverter.ToString(value.ToArray());

HmacRedactor.cs (1)

114return hmac.ComputeHash(Encoding.Unicode.GetBytes(value.ToArray()));

Resolver\DnsPrimitivesTests.cs (13)

12{ "www.example.com", "\x0003www\x0007example\x0003com\x0000"u8.ToArray() }, 13{ "example.com", "\x0007example\x0003com\x0000"u8.ToArray() }, 14{ "com", "\x0003com\x0000"u8.ToArray() }, 15{ "example", "\x0007example\x0000"u8.ToArray() }, 16{ "www", "\x0003www\x0000"u8.ToArray() }, 17{ "a", "\x0001a\x0000"u8.ToArray() }, 93ReadOnlyMemory<byte> data = "\x0003www\x0007example\x0003com\x0000"u8.ToArray(); 105Memory<byte> data = "padding\x0007example\x0003com\x0000\x0003www\x00\x07"u8.ToArray(); 117Memory<byte> data = "padding\x0007example\x0003com\x0000\x0003www\x00\x07"u8.ToArray(); 130Memory<byte> data = "\x03www\x00\x000dpadding\x0007example\x0003com\x00"u8.ToArray(); 140Memory<byte> data = "\x0003www\0\0"u8.ToArray(); 150Memory<byte> data = "\x0003com\0\x0007example\0\0\x0008example2\0\0"u8.ToArray(); 162Memory<byte> data = "\x0003www\x00c0"u8.ToArray();

Latency\Internal\LatencyContextTests.cs (7)

95Assert.Empty(measures.ToArray()); 120Assert.Single(measures.ToArray()); 146Assert.Single(measures.ToArray()); 173var tags = context.LatencyData.Tags.ToArray(); 204Assert.Single(tags.ToArray()); 256Assert.Empty(checkpoints.ToArray()); 281Assert.Single(checkpoints.ToArray());

Data\AnnotationUtils.cs (1)

414categoricalFeatures = catIndicesValues.ToArray();

UnitTests\TestVBuffer.cs (3)

291Assert.Equal(expectedIndices, a.GetIndices().ToArray()); 293var actualValues = a.GetValues().ToArray(); 317Assert.Equal(values, a.GetValues().ToArray());

Transforms\KeyToValue.cs (5)

536string[] values = Array.ConvertAll<TValue, string>(_values.GetValues().ToArray(), item => Convert.ToString(item)); 544float[] values = Array.ConvertAll<TValue, float>(_values.GetValues().ToArray(), item => Convert.ToSingle(item)); 550float[] values = Array.ConvertAll<TValue, float>(_values.GetValues().ToArray(), item => Convert.ToSingle(item)); 559string[] values = Array.ConvertAll<TValue, string>(_values.GetValues().ToArray(), item => Convert.ToString(item)); 564float[] values = Array.ConvertAll<TValue, float>(_values.GetValues().ToArray(), item => Convert.ToSingle(item));

OnnxUtils.cs (1)

570return NamedOnnxValue.CreateFromTensor<T>(name, new DenseTensor<T>(data.ToArray(), dimensions));

OnnxTransformTests.cs (5)

455Assert.Equal(0, buffera.GetValues().ToArray().Sum()); 456Assert.Equal(30, bufferb.GetValues().ToArray().Sum()); 495Assert.Equal(0, buffera.GetValues().ToArray().Sum()); 496Assert.Equal(30, bufferb.GetValues().ToArray().Sum()); 516Assert.Equal(30, bufferb.GetValues().ToArray().Sum());

Dynamic\Trainers\Clustering\KMeans.cs (2)

81string.Join(", ", centroids[0].GetValues().ToArray().Take(3))); 85string.Join(", ", centroids[1].GetValues().ToArray().Take(3)));

Dynamic\Trainers\Clustering\KMeansWithOptions.cs (2)

89string.Join(", ", centroids[0].GetValues().ToArray().Take(3))); 93string.Join(", ", centroids[1].GetValues().ToArray().Take(3)));

TensorflowTests.cs (1)

747Assert.NotEqual(trainedBias.GetValues().ToArray(), new float[] { 0.1f, 0.1f, 0.1f, 0.1f, 0.1f, 0.1f, 0.1f, 0.1f, 0.1f, 0.1f });

ImagesTests.cs (12)

1244Assert.Equal(image1.Pixels.ToArray(), image2.Pixels.ToArray()); 1258Assert.Equal(image1.Pixels.ToArray(), image3.Pixels.ToArray()); 1339Assert.Equal(image1.Pixels.ToArray(), image2.Pixels.ToArray()); 1346Assert.Equal(image1.Pixels.ToArray(), image2.Pixels.ToArray()); 1348Assert.Equal(image1.Pixels.ToArray(), image2.Pixels.ToArray()); 1373Assert.Equal(image1.Pixels.ToArray(), image2.Pixels.ToArray());

TextLoaderTests.cs (5)

923features[count] = featuresPeriod.GetValues().ToArray(); 971Assert.Equal(features[count], featuresComma.GetValues().ToArray()); 1020foreach (float feature in featuresPeriod.GetValues().ToArray()) 1089var featuresPeriodArray = featuresPeriod.GetValues().ToArray(); 1090var featuresCommaArray = featuresComma.GetValues().ToArray();

AdaptiveSingularSpectrumSequenceModeler.cs (4)

1538return result.PointForecast.GetValues().ToArray(); 1547forecast = result.PointForecast.GetValues().ToArray(); 1548confidenceIntervalLowerBounds = ssaResult.LowerBound.GetValues().ToArray(); 1549confidenceIntervalUpperBounds = ssaResult.UpperBound.GetValues().ToArray();

Normalizer\SentencePieceNormalizer.cs (1)

532normalized = blob.Slice((int)trieBlobSize).ToArray();

MissingValueReplacing.cs (1)

267T[] valReturn = srcValues.ToArray();

PermutationFeatureImportance.cs (2)

102var indexes = weights.GetIndices().ToArray(); 103var values = weights.GetValues().ToArray();

System\Windows\Media\Imaging\BitmapImage.Tests.cs (2)

20using MemoryStream stream = new("invalid image"u8.ToArray()); 65File.WriteAllBytes(tempFile, "invalid image"u8.ToArray());

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

298return abiSpan.ToArray();

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

972TSource[] chunk = new ReadOnlySpan<TSource>(source, index, Math.Min(size, source.Length - index)).ToArray();

ServerSentEvents\SseFormatter.cs (1)

21private static readonly byte[] _newLine = "\n"u8.ToArray();

System\Collections\Frozen\FrozenHashTable.cs (1)

149Debug.Assert(!hashCodesAreUnique || new HashSet<int>(hashCodes.ToArray()).Count == hashCodes.Length);

System\Collections\Immutable\ImmutableArray.cs (1)

98T[] array = items.ToArray();

System\Diagnostics\Metrics\Measurement.cs (1)

67_tags = tags.ToArray();

System\Drawing\ImageConverter.cs (1)

141return new MemoryStream(data.ToArray());

System\Drawing\Imaging\ImageCodecInfo.cs (2)

107codec.SignaturePatterns[j] = new ReadOnlySpan<byte>(codecInfo[i].SigPattern + j * codecInfo[i].SigSize, (int)codecInfo[i].SigSize).ToArray(); 108codec.SignatureMasks[j] = new ReadOnlySpan<byte>(codecInfo[i].SigMask + j * codecInfo[i].SigSize, (int)codecInfo[i].SigSize).ToArray();

System\Drawing\ImageTests.cs (6)

234item.Value = "Hello World\0"u8.ToArray(); 249item.Value = "New Value\0"u8.ToArray(); 292item.Value = "Hello World\0"u8.ToArray(); 335item.Value = "New Value\0"u8.ToArray(); 435item.Value = "Hello World\0"u8.ToArray(); 450item.Value = "New Value\0"u8.ToArray();

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

366bytes.Slice(bytes.Length - 1).ToArray(), 382bytes.Slice(i, 2).ToArray(),

System\Formats\Asn1\AsnDecoder.BitString.cs (1)

292byte[] ret = localValue.ToArray();

System\Formats\Asn1\AsnDecoder.OctetString.cs (1)

173byte[] ret = contents.ToArray();

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

181public byte[] Encode() => GetSpanEncoding().ToArray();

System\Linq\Chunk.cs (1)

66TSource[] chunk = new ReadOnlySpan<TSource>(source, index, Math.Min(size, source.Length - index)).ToArray();

src\libraries\Common\src\System\Net\Logging\NetEventSource.Common.DumpBuffer.cs (1)

35Log.DumpBuffer(IdOf(thisOrContextObject), memberName, buffer.Slice(0, Math.Min(buffer.Length, MaxDumpSize)).ToArray());

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

68private static readonly byte[] s_100continue = "HTTP/1.1 100 Continue\r\n\r\n"u8.ToArray();

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

130private static readonly byte[] s_crlf = "\r\n"u8.ToArray();

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

43private static readonly byte[] s_footer = "?="u8.ToArray();

System\Net\ServerSentEvents\SseFormatter.cs (1)

18private static readonly byte[] s_newLine = "\n"u8.ToArray();

src\libraries\System.Private.CoreLib\src\System\Collections\ObjectModel\ReadOnlyCollection.cs (1)

248values.IsEmpty ? ReadOnlyCollection<T>.Empty : new ReadOnlyCollection<T>(values.ToArray());

src\libraries\System.Private.CoreLib\src\System\Enum.cs (1)

240return new ReadOnlySpan<string>(names).ToArray();

src\libraries\System.Private.CoreLib\src\System\Enum.EnumInfo.cs (1)

39return MemoryMarshal.Cast<TStorage, TResult>(Values).ToArray();

src\libraries\System.Private.CoreLib\src\System\Globalization\StringInfo.cs (1)

224int[] retVal = builder.AsSpan().ToArray();

src\libraries\System.Private.CoreLib\src\System\Net\WebUtility.cs (1)

410result = source.ToArray();

src\libraries\System.Private.CoreLib\src\System\ReadOnlyMemory.cs (1)

355public T[] ToArray() => Span.ToArray();

src\libraries\System.Private.CoreLib\src\System\Reflection\Emit\DynamicMethod.cs (1)

333GetParametersAsSpan().ToArray();

src\libraries\System.Private.CoreLib\src\System\RuntimeType.cs (1)

124return new ReadOnlySpan<string>(ret).ToArray();

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\Helpers\AhoCorasickBuilder.cs (1)

56return new AhoCorasick(_nodes.AsSpan().ToArray(), _startingAsciiChars);

src\libraries\System.Private.CoreLib\src\System\SpanDebugView.cs (1)

19_array = span.ToArray();

src\libraries\System.Private.CoreLib\src\System\String.Manipulation.cs (2)

452return copiedLength == totalLength ? result : Concat((ReadOnlySpan<string?>)values.ToArray()); 1122JoinCore(separator, values.ToArray().AsSpan());

src\libraries\System.Private.CoreLib\src\System\Text\DecoderFallback.cs (2)

210return (Fallback(remainingBytes.Slice(0, fallbackLength).ToArray(), index: _originalByteCount - remainingBytes.Length)) 217if (Fallback(remainingBytes.Slice(0, fallbackLength).ToArray(), index: _originalByteCount - remainingBytes.Length))

src\libraries\System.Private.CoreLib\src\System\Text\Encoding.cs (4)

576char[] arrChar = new ReadOnlySpan<char>(chars, count).ToArray(); 703char[] arrChar = new ReadOnlySpan<char>(chars, charCount).ToArray(); 778byte[] arrByte = new ReadOnlySpan<byte>(bytes, count).ToArray(); 852byte[] arrByte = new ReadOnlySpan<byte>(bytes, byteCount).ToArray();

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

61_base64Bytes = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"u8.ToArray();

src\libraries\System.Private.CoreLib\src\System\Threading\Tasks\Task.cs (2)

6363Task<TResult>[] tasksCopy = tasks.ToArray(); 6556TTask[] tasksCopy = tasks.ToArray();

src\System\Reflection\AssemblyName.CoreCLR.cs (1)

80byte[] publicKeyOrToken = new ReadOnlySpan<byte>(pParts->_pPublicKeyOrToken, pParts->_cbPublicKeyOrToken).ToArray();

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

33m_binaryAttribute = binaryAttribute.ToArray();

src\System\Reflection\RuntimeConstructorInfo.CoreCLR.cs (1)

188GetParametersAsSpan().ToArray();

src\System\Reflection\RuntimePropertyInfo.cs (1)

268GetIndexParametersSpan().ToArray();

src\System\RuntimeType.CoreCLR.cs (1)

2670return new ReadOnlySpan<Type>(candidates).ToArray();

System\Xml\EncodingStreamWrapper.cs (4)

34private static readonly byte[] s_encodingUTF8 = "utf-8"u8.ToArray(); 35private static readonly byte[] s_encodingUnicode = "utf-16"u8.ToArray(); 36private static readonly byte[] s_encodingUnicodeLE = "utf-16le"u8.ToArray(); 37private static readonly byte[] s_encodingUnicodeBE = "utf-16be"u8.ToArray();

System\Xml\PrefixHandle.cs (1)

28private static readonly byte[] s_prefixBuffer = "abcdefghijklmnopqrstuvwxyz"u8.ToArray();

System\Xml\XmlBaseReader.cs (1)

2738byte[] xmlBuffer = "xmlhttp://www.w3.org/XML/1998/namespace"u8.ToArray();

System\Uri.cs (1)

4353char[] chars = str.ToArray();

System\UriHelper.cs (1)

341dest = vsb.AsSpan().ToArray();

System\Private\Windows\BinaryFormat\Deserializer\ArrayRecordDeserializer.cs (1)

41_lengths = arrayRecord.Lengths.ToArray();

System\TypeExtensions.cs (1)

275name.SetPublicKey(publicKey.ToArray());

System\Reflection\Emit\CustomAttributeWrapper.cs (1)

17_binaryAttribute = binaryAttribute.ToArray(); // TODO: Update to BlobHandle when public API public APi for MetadataBuilder.GetOrAddBlob(ReadOnlySpan<byte>) added

System\Reflection\Internal\Utilities\MemoryBlock.cs (1)

510return new ReadOnlySpan<byte>(Pointer + offset, byteCount).ToArray();

System\Reflection\Metadata\MetadataReader.WinMD.cs (1)

14internal static readonly byte[] WinRTPrefix = "<WinRT>"u8.ToArray();

System\Reflection\TypeLoading\Types\RoExceptionType.cs (2)

20_ns = ns.ToArray(); 21_name = name.ToArray();

System\Resources\Extensions\BinaryFormat\Deserializer\ArrayRecordDeserializer.cs (1)

44_lengths = arrayRecord.Lengths.ToArray();

System\Numerics\BigInteger.cs (1)

535_bits = value.ToArray();

System\Security\Cryptography\Cose\CoseHeaderValue.cs (1)

39var encodedValueCopy = new ReadOnlyMemory<byte>(encodedValue.ToArray());

Internal\Cryptography\Pal\AnyOS\ManagedPal.cs (1)

52return contents.ToArray();

src\libraries\Common\src\Internal\Cryptography\PkcsHelpers.cs (1)

350Oids.LocalKeyId => new Pkcs9LocalKeyId() { RawData = encodedAttribute.ToArray() },

src\libraries\Common\src\System\Security\Cryptography\Asn1\AlgorithmIdentifierAsn.xml.cs (1)

101decoded.Parameters = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\AttributeAsn.xml.cs (1)

111tmpItem = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\DigestInfoAsn.xml.cs (1)

81decoded.Digest = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\DirectoryStringAsn.xml.cs (1)

160decoded.UniversalString = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\EncryptedPrivateKeyInfoAsn.xml.cs (1)

81decoded.EncryptedData = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\GeneralNameAsn.xml.cs (3)

228decoded.X400Address = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray(); 234decoded.DirectoryName = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray(); 253decoded.IPAddress = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\OtherNameAsn.xml.cs (1)

98decoded.Value = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\PBEParameter.xml.cs (1)

80decoded.Salt = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\Pbkdf2SaltChoice.xml.cs (1)

105decoded.Specified = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs12\CertBagAsn.xml.cs (1)

98decoded.CertValue = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs12\MacData.xml.cs (1)

115decoded.MacSalt = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs12\SafeBagAsn.xml.cs (1)

114decoded.BagValue = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs12\SecretBagAsn.xml.cs (1)

98decoded.SecretValue = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\CertificateChoiceAsn.xml.cs (4)

200decoded.Certificate = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray(); 205decoded.ExtendedCertificate = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray(); 210decoded.AttributeCertificateV1 = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray(); 215decoded.AttributeCertificateV2 = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\ContentInfoAsn.xml.cs (1)

98decoded.Content = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\EncapsulatedContentInfoAsn.xml.cs (1)

105decoded.Content = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\EncryptedContentInfoAsn.xml.cs (1)

99decoded.EncryptedContent = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\IssuerAndSerialNumberAsn.xml.cs (2)

99decoded.Issuer = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray(); 101decoded.SerialNumber = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\OtherCertificateFormat.xml.cs (1)

93decoded.OtherCert = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\SignedDataAsn.xml.cs (1)

189tmpItem = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\SignerIdentifierAsn.xml.cs (1)

112decoded.SubjectKeyIdentifier = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\Pkcs7\SignerInfoAsn.xml.cs (2)

134decoded.SignedAttributes = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray(); 141decoded.SignatureValue = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\PrivateKeyInfoAsn.xml.cs (1)

105decoded.PrivateKey = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\Rc2CbcParameters.xml.cs (1)

86decoded.Iv = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\SubjectPublicKeyInfoAsn.xml.cs (1)

81decoded.SubjectPublicKey = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

src\libraries\Common\src\System\Security\Cryptography\Asn1\X509ExtensionAsn.xml.cs (1)

128decoded.ExtnValue = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\Asn1\CadesIssuerSerial.xml.cs (1)

103decoded.SerialNumber = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\Asn1\EssCertId.xml.cs (1)

85decoded.Hash = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\Asn1\EssCertIdV2.xml.cs (1)

125decoded.Hash = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\Asn1\KeyAgreeRecipientInfoAsn.xml.cs (1)

120decoded.Ukm = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\Asn1\KeyTransRecipientInfoAsn.xml.cs (1)

92decoded.EncryptedKey = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\Asn1\MessageImprint.xml.cs (1)

81decoded.HashedMessage = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\Asn1\OriginatorIdentifierOrKeyAsn.xml.cs (1)

123decoded.SubjectKeyIdentifier = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\Asn1\OriginatorInfoAsn.xml.cs (1)

144tmpItem = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\Asn1\OriginatorPublicKeyAsn.xml.cs (1)

81decoded.PublicKey = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\Asn1\OtherKeyAttributeAsn.xml.cs (1)

101decoded.KeyAttr = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\Asn1\PkiStatusInfo.xml.cs (1)

115decoded.StatusString = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\Asn1\PolicyQualifierInfo.xml.cs (1)

93decoded.Qualifier = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\Asn1\RecipientEncryptedKeyAsn.xml.cs (1)

81decoded.EncryptedKey = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\Asn1\RecipientIdentifierAsn.xml.cs (1)

112decoded.SubjectKeyIdentifier = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\Asn1\RecipientKeyIdentifier.xml.cs (1)

92decoded.SubjectKeyIdentifier = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\Asn1\Rfc3161TimeStampReq.xml.cs (1)

160decoded.Nonce = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\Asn1\Rfc3161TimeStampResp.xml.cs (1)

94decoded.TimeStampToken = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\Asn1\Rfc3161TstInfo.xml.cs (2)

168decoded.SerialNumber = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray(); 194decoded.Nonce = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();

System\Security\Cryptography\Pkcs\CmsSignature.ECDsa.cs (1)

200dataHash.ToArray()

System\Security\Cryptography\Pkcs\CmsSignature.RSA.cs (1)

154dataHash.ToArray(),

System\Security\Cryptography\Pkcs\Rfc3161TimestampRequest.cs (1)

364_encodedBytes = firstElement.ToArray(),

System\Security\Cryptography\Pkcs\SubjectIdentifier.cs (1)

82var name = new X500DistinguishedName(issuerNameSpan.ToArray());

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

40rgbData = "\""u8.ToArray();

System\Security\Cryptography\Xml\CanonicalXmlComment.cs (4)

55rgbData = "(char) 10"u8.ToArray(); 59rgbData = ""u8.ToArray(); 67rgbData = "(char) 10"u8.ToArray();

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

149rgbData = ">"u8.ToArray();

System\Security\Cryptography\Xml\CanonicalXmlProcessingInstruction.cs (4)

50rgbData = "(char) 10"u8.ToArray(); 54rgbData = "<?"u8.ToArray(); 66rgbData = "?>"u8.ToArray(); 71rgbData = "(char) 10"u8.ToArray();

System\Text\Json\Document\JsonDocument.Parse.cs (4)

683owned = valueSpan.ToArray(); 697s_falseLiteral ??= Create(JsonConstants.FalseValue.ToArray()); 700s_trueLiteral ??= Create(JsonConstants.TrueValue.ToArray()); 704s_nullLiteral ??= Create(JsonConstants.NullValue.ToArray());

System\Text\Json\JsonEncodedText.cs (1)

134return new JsonEncodedText(utf8Value.ToArray());

System\Text\Json\Serialization\JsonSerializer.Read.HandleMetadata.cs (4)

20private static readonly byte[] s_idPropertyName = "$id"u8.ToArray(); 21private static readonly byte[] s_refPropertyName = "$ref"u8.ToArray(); 22private static readonly byte[] s_typePropertyName = "$type"u8.ToArray(); 23private static readonly byte[] s_valuesPropertyName = "$values"u8.ToArray();

System\Text\Json\Serialization\JsonSerializer.Write.ByteArray.cs (2)

138return output.WrittenSpan.ToArray(); 155return output.WrittenSpan.ToArray();

System\Text\Json\Serialization\Metadata\JsonTypeInfo.Cache.cs (1)

154utf8PropertyName = propertyName.ToArray();

System\Text\Json\ThrowHelper.Node.cs (1)

59string concatenatedNames = supportedTypeNames.Length == 1 ? supportedTypeNames[0] : string.Join(", ", supportedTypeNames.ToArray());

System\Text\Json\ThrowHelper.Serialization.cs (7)

444state.Current.JsonPropertyName = propertyName.ToArray(); 722state.Current.JsonPropertyName = propertyName.ToArray(); 729state.Current.JsonPropertyName = propertyName.ToArray(); 748state.Current.JsonPropertyName = propertyName.ToArray(); 755state.Current.JsonPropertyName = propertyName.ToArray(); 769state.Current.JsonPropertyName = propertyName.ToArray(); 796state.Current.JsonPropertyName = reader.HasValueSequence ? reader.ValueSequence.ToArray() : reader.ValueSpan.ToArray();

System\Text\RegularExpressions\RegexCompiler.cs (2)

1007LoadSearchValues(asciiChars.AsSpan().ToArray()); 6174LoadSearchValues(chars.ToArray());

System\Text\RegularExpressions\RegexReplacement.cs (2)

90_strings = strings.AsSpan().ToArray(); 91_rules = rules.AsSpan().ToArray();

System\Text\RegularExpressions\RegexWriter.cs (1)

112int[] emitted = _emitted.AsSpan().ToArray();

RegexGenerator.Emitter.cs (1)

406? EmitSearchValues(chars.ToArray(), requiredHelpers)

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

405return bytes.ToArray();

Interop\ComCtl32\LVITEMWTests.cs (1)

88Assert.Equal(sText.ToArray(), new char[] { '0', '1', '2', '3', '4', '5', '\0' });

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

43decoded.ToArray().Should().BeEquivalentTo(data.ToArray());

System\SpanReaderTests.cs (9)

17read.ToArray().Should().BeEquivalentTo([1, 2]); 21read.ToArray().Should().BeEquivalentTo([4]); 32read.ToArray().Should().BeEquivalentTo([1, 2]); 36read.ToArray().Should().BeEquivalentTo([3, 4]); 40read.ToArray().Should().BeEmpty(); 120value.ToArray().Should().BeEquivalentTo([new Point(1, 2), new Point(3, 4)]); 126value.ToArray().Should().BeEmpty(); 149read.ToArray().Should().BeEquivalentTo([1, 2]); 153read.ToArray().Should().BeEquivalentTo([3, 4]);

Metafiles\RecordTypes\EMRPOLY16.cs (1)

42public override string ToString() => $"[EMR{emr.iType}] Bounds: {rclBounds} Points: {string.Join(' ', points.ToArray())}";

Metafiles\RecordTypes\EMRPOLYPOLY16.cs (1)

45sb.Append($"\n\tPoly index {i}: {string.Join(' ', GetPointsForPoly(i).ToArray())}");

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

1136array.Should().BeEquivalentTo("Hello, World!\0"u8.ToArray());

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

972TSource[] chunk = new ReadOnlySpan<TSource>(source, index, Math.Min(size, source.Length - index)).ToArray();

Program.cs (1)

148await stream.Transport.Output.WriteAsync(new("Created a new stream from the client and sent this message then closing the stream."u8.ToArray()));

MemoryAsserts.cs (2)

241 Equal<object>(expectedMemory.Span.ToArray(), actualMemory.Span.ToArray());

SpanAsserts.cs (2)

250 Equal<object>(expectedSpan.ToArray(), actualSpan.ToArray());