ToArray

1 override of ToArray

System.Private.CoreLib (1)

src\libraries\System.Private.CoreLib\src\System\IO\UnmanagedMemoryStreamWrapper.cs (1)

90public override byte[] ToArray()

452 references to ToArray

aspire (1)

src\Shared\Mcp\McpIconHelper.cs (1)

37var data = memoryStream.ToArray();

Aspire.Dashboard (2)

Model\TextVisualizerViewModel.cs (1)

182var formattedJson = Encoding.UTF8.GetString(stream.ToArray());

src\Shared\Mcp\McpIconHelper.cs (1)

37var data = memoryStream.ToArray();

Aspire.Hosting.Azure.EventHubs (2)

AzureEventHubsExtensions.cs (2)

346Contents = Encoding.UTF8.GetString(writeStream.ToArray()), 476return Encoding.UTF8.GetString(stream.ToArray());

Aspire.Hosting.Azure.ServiceBus (2)

AzureServiceBusExtensions.cs (2)

499Contents = Encoding.UTF8.GetString(writeStream.ToArray()), 639return Encoding.UTF8.GetString(stream.ToArray());

Aspire.Hosting.PostgreSQL (1)

PostgresBuilderExtensions.cs (1)

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

Aspire.Hosting.Tests (33)

ApplicationModel\Docker\DockerfileBuilderEdgeCasesTests.cs (6)

46var content = Encoding.UTF8.GetString(stream.ToArray()); 78var content = Encoding.UTF8.GetString(stream.ToArray()); 103var content = Encoding.UTF8.GetString(stream.ToArray()); 132var content = Encoding.UTF8.GetString(stream.ToArray()); 189var content = Encoding.UTF8.GetString(stream.ToArray()); 231var content = Encoding.UTF8.GetString(stream.ToArray());

ApplicationModel\Docker\DockerfileBuilderIntegrationTests.cs (2)

41var content = Encoding.UTF8.GetString(stream.ToArray()); 116var content = Encoding.UTF8.GetString(stream.ToArray());

ApplicationModel\Docker\DockerfileBuilderTests.cs (2)

131var content = Encoding.UTF8.GetString(stream.ToArray()); 170var content = Encoding.UTF8.GetString(stream.ToArray());

ApplicationModel\Docker\DockerfileStageTests.cs (7)

327var content = Encoding.UTF8.GetString(stream.ToArray()); 361var content = Encoding.UTF8.GetString(stream.ToArray()); 397var content = Encoding.UTF8.GetString(stream.ToArray()); 428var content = Encoding.UTF8.GetString(stream.ToArray()); 470var content = Encoding.UTF8.GetString(stream.ToArray()); 528var content = Encoding.UTF8.GetString(stream.ToArray()); 563var content = Encoding.UTF8.GetString(stream.ToArray());

ApplicationModel\Docker\DockerfileStatementsTests.cs (16)

BuildValidator (1)

CompilationDiff.cs (1)

158var rebuildBytes = rebuildPeStream.ToArray();

GenerateDocumentationAndConfigFiles (2)

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

75return memoryStream.ToArray();

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

127return ImmutableArray.Create<byte>(stream.ToArray());

IdentitySample.PasskeyConformance (1)

Program.cs (1)

234var resultBytes = stream.ToArray();

illink (1)

Linker\CustomSymbolWriter.cs (1)

79var newData = newDataStream.ToArray();

InMemory.FunctionalTests (6)

ChunkedRequestTests.cs (1)

129var bytes = data.ToArray();

RequestTests.cs (3)

1130Assert.Equal(22, ms1.ToArray().Length); 1131Assert.Empty(ms2.ToArray()); 1416var request = ms.ToArray();

src\Servers\Kestrel\shared\test\TestApp.cs (2)

33var bytes = data.ToArray(); 67var bytes = data.ToArray();

Metrics (2)

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

75return memoryStream.ToArray();

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

127return ImmutableArray.Create<byte>(stream.ToArray());

Metrics.Legacy (2)

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

75return memoryStream.ToArray();

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

127return ImmutableArray.Create<byte>(stream.ToArray());

Microsoft.AspNetCore.Authentication (2)

PropertiesSerializer.cs (1)

27return memory.ToArray();

TicketSerializer.cs (1)

32return memory.ToArray();

Microsoft.AspNetCore.Authentication.Twitter (1)

Messages\RequestTokenSerializer.cs (1)

26return memory.ToArray();

Microsoft.AspNetCore.Components.Endpoints (2)

Builder\ResourceCollectionUrlEndpoint.cs (2)

88return gzipContent.ToArray(); 107return content.ToArray();

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

Circuits\RemoteJSDataStreamTest.cs (2)

65Assert.Equal(chunk, memoryStream.ToArray()); 93Assert.Equal(chunk, memoryStream.ToArray());

Circuits\RenderBatchWriterTest.cs (1)

279return new Span<byte>(ms.ToArray(), 0, (int)ms.Length);

ElementReferenceJsonConverterTest.cs (1)

35var json = Encoding.UTF8.GetString(memoryStream.ToArray());

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

HtmlRendering\HtmlRendererTest.cs (1)

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

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

PullFromJSDataStreamTest.cs (1)

60Assert.Equal(Data, mem.ToArray());

Microsoft.AspNetCore.DataProtection.Tests (1)

KeyManagement\KeyRingBasedDataProtectorTests.cs (1)

791expectedAad = expectedAad.Concat(memStream.ToArray());

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

ProblemDetailsJsonConverterTest.cs (3)

185var actual = Encoding.UTF8.GetString(stream.ToArray()); 209var actual = Encoding.UTF8.GetString(stream.ToArray()); 240var actual = Encoding.UTF8.GetString(stream.ToArray());

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

HttpConnectionDispatcherTests.cs (25)

LongPollingTests.cs (2)

81Assert.Equal("Hello World", Encoding.UTF8.GetString(ms.ToArray())); 108var payload = ms.ToArray();

ServerSentEventsMessageFormatterTests.cs (2)

25Assert.Equal(encoded, Encoding.UTF8.GetString(output.ToArray())); 37Assert.Equal(encoded, Encoding.UTF8.GetString(output.ToArray()));

ServerSentEventsTests.cs (3)

79Assert.Equal(":\r\ndata: Hello\r\n\r\n", Encoding.ASCII.GetString(ms.ToArray())); 104Assert.Equal(":\r\ndata: " + hText + wText + "\r\n\r\n", Encoding.ASCII.GetString(ms.ToArray())); 130Assert.Equal(expected, Encoding.UTF8.GetString(ms.ToArray()));

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

AcceptedAtRouteOfTResultTests.cs (1)

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

AcceptedOfTResultTests.cs (1)

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

BadRequestOfTResultTests.cs (1)

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

ConflictOfTResultTests.cs (1)

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

ContentResultTests.cs (1)

122Assert.Equal(expectedContentData, memoryStream.ToArray());

CreatedOfTResultTests.cs (1)

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

HttpResultsHelperTests.cs (6)

40var body = JsonSerializer.Deserialize<TodoStruct>(responseBodyStream.ToArray(), serializerOptions); 71var body = JsonSerializer.Deserialize<Todo>(responseBodyStream.ToArray(), serializerOptions); 104var body = JsonSerializer.Deserialize<TodoChild>(responseBodyStream.ToArray(), serializerOptions); 138var body = JsonSerializer.Deserialize<TodoChild>(responseBodyStream.ToArray(), serializerOptions); 172var body = JsonSerializer.Deserialize<TodoJsonChild>(responseBodyStream.ToArray(), serializerOptions); 200var body = JsonSerializer.Deserialize<JsonTodo[]>(responseBodyStream.ToArray(), serializerOptions);

InternalServerErrorOfTResultTests.cs (1)

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

JsonResultTests.cs (2)

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

OkOfTResultTests.cs (1)

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

PushStreamResultTests.cs (1)

26Assert.Equal("Hello World", Encoding.UTF8.GetString(ms.ToArray()));

ServerSentEventsResultTests.cs (11)

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

41Assert.Equal(buffer, outStream.ToArray()); 349Assert.Equal(buffer, outStream.ToArray());

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

390var outBytes = outStream.ToArray(); 415var outBytes = outStream.ToArray();

UnprocessableEntityOfTResultTests.cs (1)

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

Utf8ContentResultTests.cs (2)

43Assert.Equal(data, ms.ToArray()); 61Assert.Equal(data, ms.ToArray());

Microsoft.AspNetCore.Identity (1)

DataProtectorTokenProvider.cs (1)

93var protectedBytes = Protector.Protect(ms.ToArray());

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

FunctionalTest.cs (2)

424await res.Body.WriteAsync(memory.ToArray(), 0, memory.ToArray().Length);

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

ContentResultTest.cs (1)

139Assert.Equal(expectedContentData, memoryStream.ToArray());

Formatters\JsonOutputFormatterTestBase.cs (2)

104var actualContent = encoding.GetString(body.ToArray()); 136var actualContent = encoding.GetString(body.ToArray());

Formatters\SystemTextJsonOutputFormatterTest.cs (6)

58var actualContent = encoding.GetString(body.ToArray()); 113Assert.Equal(expected.ToArray(), body.ToArray()); 144Assert.InRange(body.ToArray().Length, 0, 1); 204var actualContent = encoding.GetString(body.ToArray()); 244var actualContent = encoding.GetString(body.ToArray());

Infrastructure\JsonResultExecutorTestBase.cs (1)

499return Assert.IsType<MemoryStream>(context.Response.Body).ToArray();

Infrastructure\ValidationProblemDetailsJsonConverterTest.cs (2)

152var json = Encoding.UTF8.GetString(stream.ToArray()); 185var json = Encoding.UTF8.GetString(stream.ToArray());

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

41Assert.Equal(buffer, outStream.ToArray()); 349Assert.Equal(buffer, outStream.ToArray());

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

390var outBytes = outStream.ToArray(); 415var outBytes = outStream.ToArray();

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

XmlDataContractSerializerOutputFormatterTest.cs (2)

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

XmlSerializerOutputFormatterTest.cs (2)

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

Microsoft.AspNetCore.Mvc.NewtonsoftJson (1)

BsonTempDataSerializer.cs (1)

142return memoryStream.ToArray();

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

JsonResultTest.cs (1)

66return Assert.IsType<MemoryStream>(context.Response.Body).ToArray();

NewtonsoftJsonOutputFormatterTest.cs (2)

462Assert.Empty(body.ToArray()); 541Assert.Empty(body.ToArray());

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

104var actualContent = encoding.GetString(body.ToArray()); 136var actualContent = encoding.GetString(body.ToArray());

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

499return Assert.IsType<MemoryStream>(context.Response.Body).ToArray();

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

RuntimeViewCompiler.cs (2)

365var assembly = Assembly.Load(assemblyStream.ToArray(), pdbStream?.ToArray());

Microsoft.AspNetCore.Mvc.TagHelpers (1)

Cache\DistributedCacheTagHelperService.cs (1)

174return buffer.ToArray();

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

ViewExecutorTest.cs (3)

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

Microsoft.AspNetCore.OpenApi.Tests (4)

Extensions\OpenApiEndpointRouteBuilderExtensionsTests.cs (4)

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

Microsoft.AspNetCore.OutputCaching.Tests (2)

OutputCacheMiddlewareTests.cs (2)

1007Assert.Equal("Hello1", Encoding.UTF8.GetString(memoryStream1.ToArray())); 1008Assert.Equal("Hello2", Encoding.UTF8.GetString(memoryStream2.ToArray()));

Microsoft.AspNetCore.RequestDecompression.Tests (8)

RequestDecompressionMiddlewareTests.cs (8)

43return compressedStream.ToArray(); 253decompressedBytes = ms.ToArray(); 324outputBytes = ms.ToArray(); 499decompressedBytes = ms.ToArray(); 502decompressedBytes = ms.ToArray(); 583decompressedBytes = ms.ToArray(); 586decompressedBytes = ms.ToArray(); 737outputContent = ms.ToArray();

Microsoft.AspNetCore.ResponseCaching (3)

src\Shared\SegmentWriteStream.cs (3)

70_segments.Add(_bufferStream.ToArray()); 139_segments.Add(_bufferStream.ToArray()); 172_segments.Add(_bufferStream.ToArray());

Microsoft.AspNetCore.ResponseCompression.Tests (4)

ResponseCompressionBodyTest.cs (4)

42Assert.Equal(buffer, memoryStream.ToArray()); 58Assert.Equal(buffer, memoryStream.ToArray()); 73Assert.Equal(File.ReadAllBytes(path), memoryStream.ToArray()); 90Assert.Equal(buffer, memoryStream.ToArray());

Microsoft.AspNetCore.Routing.Tests (4)

Builder\RequestDelegateEndpointRouteBuilderExtensionsTest.cs (4)

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

Microsoft.AspNetCore.Server.IIS (1)

StartupHook.cs (1)

69var content = stream.ToArray();

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

MessageBodyTests.cs (1)

534var requestArray = ms.ToArray();

src\Servers\Kestrel\shared\test\TestApp.cs (2)

33var bytes = data.ToArray(); 67var bytes = data.ToArray();

Microsoft.AspNetCore.Session (1)

DistributedSession.cs (1)

281stream.ToArray(),

Microsoft.AspNetCore.Shared.Tests (3)

src\Shared\SegmentWriteStream.cs (3)

70_segments.Add(_bufferStream.ToArray()); 139_segments.Add(_bufferStream.ToArray()); 172_segments.Add(_bufferStream.ToArray());

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

TestConnection.cs (1)

220return output.ToArray();

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

Internal\Formatters\TextMessageFormatterTests.cs (1)

22Assert.Equal("ABC\u001e", Encoding.UTF8.GetString(ms.ToArray()));

Internal\Protocol\JsonHubProtocolTestsBase.cs (1)

509return output.ToArray();

Internal\Protocol\MemoryBufferWriterTests.cs (2)

241var data = ms.ToArray(); 260var data = ms.ToArray();

Microsoft.AspNetCore.WebUtilities.Tests (38)

FileBufferingReadStreamTests.cs (7)

479Assert.Equal(data, withoutBufferMs.ToArray()); 481Assert.Equal(data, withBufferMs.ToArray()); 503Assert.Equal(data, withoutBufferMs.ToArray()); 505Assert.Equal(data, withBufferMs.ToArray()); 523Assert.Equal(data.AsMemory(100).ToArray(), withoutBufferMs.ToArray()); 541Assert.Equal(data.AsMemory(read).ToArray(), withoutBufferMs.ToArray()); 560Assert.Equal(data.ToArray(), withoutBufferMs.ToArray());

FileBufferingWriteStreamTests.cs (4)

348Assert.Equal(input, memoryStream.ToArray()); 365Assert.Equal(input, memoryStream.ToArray()); 403return memoryStream.ToArray(); 411return memoryStream.ToArray();

HttpResponseStreamWriterTest.cs (4)

30Assert.Equal(expectedData, memoryStream.ToArray()); 640Assert.Equal(expectedBytes, stream.ToArray()); 675Assert.Equal(expectedBytes, stream.ToArray()); 703Assert.Equal(expectedBytes, stream.ToArray());

MultipartReaderTests.cs (15)

PagedByteBufferTest.cs (8)

109Assert.Equal(input, stream.ToArray()); 118Assert.Equal(newInput, stream.ToArray()); 134Assert.Equal(input, stream.ToArray()); 142Assert.Equal(newInput, stream.ToArray()); 158Assert.Equal(input, stream.ToArray()); 185Assert.Equal(input, memoryStream.ToArray()); 210Assert.Equal(input, memoryStream.ToArray()); 241return stream.ToArray();

Microsoft.CodeAnalysis (2)

InternalUtilities\StreamExtensions.cs (1)

75return memoryStream.ToArray();

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

127return ImmutableArray.Create<byte>(stream.ToArray());

Microsoft.CodeAnalysis.Analyzers (2)

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

75return memoryStream.ToArray();

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

127return ImmutableArray.Create<byte>(stream.ToArray());

Microsoft.CodeAnalysis.AnalyzerUtilities (2)

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

75return memoryStream.ToArray();

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

127return ImmutableArray.Create<byte>(stream.ToArray());

Microsoft.CodeAnalysis.BannedApiAnalyzers (2)

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

75return memoryStream.ToArray();

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

127return ImmutableArray.Create<byte>(stream.ToArray());

Microsoft.CodeAnalysis.CodeStyle (3)

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

229var jsonBytes = stream.ToArray();

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

75return memoryStream.ToArray();

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

127return ImmutableArray.Create<byte>(stream.ToArray());

Microsoft.CodeAnalysis.Collections.Package (1)

Extensions\ImmutableArrayExtensions.cs (1)

127return ImmutableArray.Create<byte>(stream.ToArray());

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

Emit\CompilationEmitTests.cs (16)

216mdOnlyImage = output.ToArray(); 244Assert.True(output.ToArray().Length > 0, "no metadata emitted"); 273mdOnlyImage = peStream.ToArray(); 274xmlDocBytes = xmlStream.ToArray(); 318mdOnlyImage = peStream.ToArray(); 319xmlDocBytes = xmlStream.ToArray(); 364mdOnlyImage = peStream.ToArray(); 365xmlDocBytes = xmlStream.ToArray(); 418mdOnlyImage = peStream.ToArray(); 419xmlDocBytes = xmlStream.ToArray(); 474mdOnlyImage = peStream.ToArray(); 475xmlDocBytes = xmlStream.ToArray(); 527mdOnlyImage = peStream.ToArray(); 528xmlDocBytes = xmlStream.ToArray(); 895var metadataRef = AssemblyMetadata.CreateFromImage(stream.ToArray()).GetReference(); 2710dllImage = output.ToArray();

Emit\DeterministicTests.cs (1)

498var newResult = streamDll.ToArray();

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

Emit\EditAndContinue\AssemblyReferencesTests.cs (2)

86var il = ImmutableArray.Create(ilStream.ToArray()); 162var il = ImmutableArray.Create(ilStream.ToArray());

Microsoft.CodeAnalysis.CSharp.Scripting.Desktop.UnitTests (1)

ObjectFormatterTests.cs (1)

113a = Assembly.Load(stream.ToArray());

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

CSharpTestBase.cs (1)

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

Microsoft.CodeAnalysis.EditorFeatures.UnitTests (1)

Emit\CompilationOutputFilesTests.cs (1)

38var pdbFile = dir.CreateFile("a.pdb").WriteAllBytes(pdbStream.ToArray());

Microsoft.CodeAnalysis.Extensions.Package (1)

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

127return ImmutableArray.Create<byte>(stream.ToArray());

Microsoft.CodeAnalysis.Features (2)

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

229var jsonBytes = stream.ToArray();

SymbolSearch\Windows\SymbolSearchUpdateEngine.Update.cs (1)

737var bytes = outStream.ToArray();

Microsoft.CodeAnalysis.InteractiveHost (1)

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

127return ImmutableArray.Create<byte>(stream.ToArray());

Microsoft.CodeAnalysis.LanguageServer.UnitTests (1)

ExportProviderBuilderTests.cs (1)

140tempFile.WriteAllBytes(dllData.ToArray());

Microsoft.CodeAnalysis.PerformanceSensitiveAnalyzers (2)

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

75return memoryStream.ToArray();

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

127return ImmutableArray.Create<byte>(stream.ToArray());

Microsoft.CodeAnalysis.PublicApiAnalyzers (2)

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

75return memoryStream.ToArray();

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

127return ImmutableArray.Create<byte>(stream.ToArray());

Microsoft.CodeAnalysis.Rebuild.UnitTests (5)

RoundTripUtil.cs (5)

59Assert.Equal(peStream.ToArray(), rebuildPeStream.ToArray()); 60Assert.Equal(pdbStream?.ToArray(), rebuildPdbStream?.ToArray()); 210return Encoding.UTF8.GetString(stream.ToArray());

Microsoft.CodeAnalysis.ResxSourceGenerator (2)

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

75return memoryStream.ToArray();

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

127return ImmutableArray.Create<byte>(stream.ToArray());

Microsoft.CodeAnalysis.Test.Utilities (3)

Mocks\Silverlight.cs (2)

103return (mscorlib.ToArray(), system.ToArray());

TestableFile.cs (1)

52MemoryFile.Contents.AddRange(this.ToArray());

Microsoft.CodeAnalysis.Threading.Package (1)

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

127return ImmutableArray.Create<byte>(stream.ToArray());

Microsoft.CodeAnalysis.UnitTests (4)

Diagnostics\SarifErrorLoggerTests.cs (3)

47string actual = Encoding.UTF8.GetString(stream.ToArray()); 87string actual = Encoding.UTF8.GetString(stream.ToArray()); 127var buffer = stream.ToArray();

EmbeddedTextTests.cs (1)

268return destination.ToArray();

Microsoft.CodeAnalysis.Workspaces (3)

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

75return memoryStream.ToArray();

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

127return ImmutableArray.Create<byte>(stream.ToArray());

Storage\SQLite\v2\SQLitePersistentStorage_Helpers.cs (1)

49var bytes = tempStream.ToArray();

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

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

75return memoryStream.ToArray();

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

127return ImmutableArray.Create<byte>(stream.ToArray());

Microsoft.CodeAnalysis.Workspaces.UnitTests (1)

FindAllDeclarationsTests.cs (1)

637using var readerStream = new MemoryStream(writerStream.ToArray());

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

GenerateNuSpec.cs (1)

145newSource = Encoding.UTF8.GetString(stream.ToArray());

Microsoft.DotNet.NuGetRepack.Tests (1)

VersionUpdaterTests.cs (1)

31return (e.FullName, m.ToArray());

Microsoft.DotNet.SignCheckLibrary (2)

Verification\DebVerifier.cs (1)

42=> File.WriteAllBytes(targetPath, ((MemoryStream)archiveEntry.ContentStream).ToArray());

Verification\Jar\JarUtils.cs (1)

35return ms.ToArray();

Microsoft.Extensions.AI.Evaluation.Integration.Tests (1)

test\Shared\ImageDataUri\ImageDataUri.cs (1)

22return new Uri($"data:image/png;base64,{Convert.ToBase64String(ms.ToArray())}");

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

ImageGeneratorIntegrationTests.cs (1)

122return ms.ToArray();

test\Shared\ImageDataUri\ImageDataUri.cs (1)

22return new Uri($"data:image/png;base64,{Convert.ToBase64String(ms.ToArray())}");

Microsoft.Extensions.AI.OpenAI (1)

ResponsesClientContinuationToken.cs (1)

52return stream.ToArray();

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

OpenAIResponseClientTests.cs (1)

6241return stream.ToArray();

test\Shared\ImageDataUri\ImageDataUri.cs (1)

22return new Uri($"data:image/png;base64,{Convert.ToBase64String(ms.ToArray())}");

Microsoft.Extensions.Caching.Hybrid.Tests (1)

SampleUsage.cs (1)

183return ms.ToArray();

Microsoft.Extensions.Logging.EventSource (1)

EventSourceLogger.cs (1)

279buffer = new ArraySegment<byte>(stream.ToArray());

Microsoft.Gen.Logging.Unit.Tests (1)

CompilationHelper.cs (1)

63return ms.ToArray();

Microsoft.Maui (1)

VisualDiagnostics\VisualDiagnostics.cs (1)

113 return ms.ToArray();

Microsoft.Maui.Graphics (9)

ImageExtensions.cs (2)

17 return stream.ToArray(); 41 return stream.ToArray();

PdfPageExtensions.cs (2)

17 return stream.ToArray(); 41 return stream.ToArray();

PictureReaderExtensions.cs (2)

16 var bytes = memoryStream.ToArray(); 28 var bytes = memoryStream.ToArray();

PictureWriterExtensions.cs (2)

17 return stream.ToArray(); 29 return stream.ToArray();

PlatformImage.cs (1)

186 return new PlatformImage(memoryStream.ToArray(), format);

Microsoft.ML.AutoML (1)

ColumnInference\TextFileSample.cs (1)

203var resultBuffer = resultStream.ToArray();

Microsoft.ML.Data (2)

Transforms\InvertHashUtils.cs (1)

408ctx.Writer.WriteByteArray(mem.ToArray());

Transforms\ValueMapping.cs (1)

1010return strm.ToArray();

Microsoft.ML.FastTree (1)

Utils\CompressUtils.cs (1)

111return ms.ToArray();

Microsoft.ML.Parquet (2)

ParquetLoader.cs (1)

429ctx.SaveBinaryStream(SchemaCtxName, w => w.WriteByteArray(strm.ToArray()));

PartitionedFileLoader.cs (1)

280ctx.SaveBinaryStream(SchemaCtxName, w => w.WriteByteArray(strm.ToArray()));

Microsoft.ML.Predictor.Tests (1)

TestTransposer.cs (1)

246src = new BytesStreamSource(mem.ToArray());

Microsoft.ML.Samples (1)

Dynamic\Transforms\TimeSeries\DetectChangePointBySsaStream.cs (1)

104modelBytes = stream.ToArray();

Microsoft.ML.TensorFlow (1)

TensorflowTransform.cs (1)

461w.WriteByteArray(buffer.DangerousMemoryBlock.ToArray());

Microsoft.ML.Transforms (1)

OptionalColumnTransform.cs (1)

150ctx.SaveBinaryStream("Schema.idv", w => w.WriteByteArray(strm.ToArray()));

Microsoft.ML.Vision (1)

ImageClassificationTrainer.cs (1)

1442w.WriteByteArray(buffer.DangerousMemoryBlock.ToArray());

Microsoft.VisualBasic.Forms.Tests (4)

System\Windows\Forms\ClipboardProxyTests.vb (4)

40clipboardProxyAudio.ToArray.Should.BeEquivalentTo(clipboardAudio.ToArray) 54clipboardProxyWaveAudio.ToArray.Should.BeEquivalentTo(clipboardWaveAudio.ToArray)

Microsoft.VisualStudio.Extensibility.Testing.Xunit (1)

src\VisualStudio\IntegrationTest\Harness\XUnitShared\Harness\VisualStudioInstanceFactory.cs (1)

70return Assembly.Load(memoryStream.ToArray());

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

PersistentStorage\AbstractPersistentStorageTests.cs (1)

1074return _encoding.GetString(memoryStream.ToArray());

ProjectSystemShim\VisualStudioCompilationOutputFilesTests.cs (1)

45pdbFile.WriteAllBytes(pdbStream.ToArray());

PresentationBuildTasks (7)

Microsoft\Build\Tasks\Windows\MarkupCompilePass2.cs (1)

675TaskFileService.WriteFile(memStream.ToArray(), _internalTypeHelperFile);

MS\Internal\Localization\LocalizationParserHooks.cs (1)

134_compiler.TaskFileService.WriteFile(memStream.ToArray(), absoluteOutputPath);

MS\Internal\MarkupCompiler\MarkupCompiler.cs (3)

642TaskFileService.WriteGeneratedCodeFile(codeMemStream.ToArray(), 2985TaskFileService.WriteGeneratedCodeFile(codeMemStream.ToArray(), 3295TaskFileService.WriteGeneratedCodeFile(codeMemStream.ToArray(),

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

224_taskFileService.WriteFile(memStream.ToArray(), _localCacheFile);

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

137_taskFileService.WriteFile(memStream.ToArray(), _stateFilePath);

PresentationCore (3)

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

731byte[] data = localStream.ToArray();

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

614cbData += ExtendedPropertySerializer.EncodeAsISF(KnownIds.StylusTip, localStream.ToArray(), stream, guidList, 0, true);

System\Windows\Ink\StrokeCollectionConverter.cs (1)

122return Convert.ToBase64String(ms.ToArray());

PresentationCore.Tests (4)

System\Windows\ClipboardTests.cs (4)

32Clipboard.GetAudioStream().Should().BeOfType<MemoryStream>().Which.ToArray().Should().Equal(audioBytes); 33Clipboard.GetData(DataFormats.WaveAudio).Should().BeOfType<MemoryStream>().Which.ToArray().Should().Equal(audioBytes); 65Clipboard.GetAudioStream().Should().BeOfType<MemoryStream>().Which.ToArray().Should().Equal(audioBytes); 66Clipboard.GetData(DataFormats.WaveAudio).Should().BeOfType<MemoryStream>().Which.ToArray().Should().Equal(audioBytes);

PresentationFramework (1)

MS\Internal\DataStreams.cs (1)

142bytes = byteStream.ToArray();

PresentationUI (1)

MS\Internal\Documents\PeoplePickerWrapper.cs (1)

322byte[] data = dataStream.ToArray();

ReachFramework (1)

PrintConfig\PrtTicket_Public_Simple.cs (1)

1403return System.Text.Encoding.UTF8.GetString(ms.ToArray());

Roslyn.Diagnostics.Analyzers (2)

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

75return memoryStream.ToArray();

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

127return ImmutableArray.Create<byte>(stream.ToArray());

Shared.Tests (1)

ImageDataUri\ImageDataUri.cs (1)

22return new Uri($"data:image/png;base64,{Convert.ToBase64String(ms.ToArray())}");

SocialWeather (1)

PersistentConnectionLifeTimeManager.cs (1)

50await connection.Transport.Output.WriteAsync(ms.ToArray());

Sockets.FunctionalTests (2)

src\Servers\Kestrel\shared\test\TestApp.cs (2)

33var bytes = data.ToArray(); 67var bytes = data.ToArray();

System.Configuration.ConfigurationManager (1)

System\Configuration\SettingsPropertyValue.cs (1)

237return ms.ToArray();

System.Data.Common (1)

System\Data\Common\DbDataReader.cs (1)

227return new MemoryStream(bufferStream.ToArray(), false);

System.Drawing.Common (5)

System\Drawing\Icon.cs (1)

143si.AddValue("IconData", stream.ToArray(), typeof(byte[]));

System\Drawing\IconConverter.cs (1)

47return ms.ToArray();

System\Drawing\Image.cs (1)

78si.AddValue("Data", stream.ToArray(), typeof(byte[])); // Do not rename (binary serialization)

System\Drawing\ImageConverter.cs (1)

65return ms.ToArray();

System\Drawing\Printing\PrinterSettings.cs (1)

389byte[] pvImage = stream.ToArray();

System.Drawing.Common.Tests (5)

System\Drawing\IconConverterTests.cs (1)

27_iconBytes = destStream.ToArray();

System\Drawing\IconTests.cs (2)

435Assert.Equal(File.ReadAllBytes(filePath), outputStream.ToArray()); 446Assert.Equal(File.ReadAllBytes(filePath), outputStream.ToArray());

System\Drawing\ImageConverterTests.cs (2)

25_imageBytes = destStream.ToArray(); 54object image = converter.ConvertFrom(ms.ToArray());

System.Net.Security (2)

src\libraries\Common\src\System\Net\Http\X509ResourceClient.cs (1)

264return result.ToArray();

System\Net\Security\CipherSuitesPolicyPal.Linux.cs (1)

225return _ms.ToArray();

System.Private.CoreLib (1)

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

238m_blob = ((MemoryStream)writer.BaseStream).ToArray();

System.Private.DataContractSerialization (1)

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

104adapter.Buffer ??= memoryStream.ToArray(); // couldn't get the inner buffer; clone it now

System.Private.Windows.Core.Tests (4)

System\Private\Windows\Nrbf\BinaryFormatterHelpers.cs (1)

77return stream.ToArray();

System\Private\Windows\Ole\ClipboardCoreTests.cs (1)

435outData.GetData(DataFormatNames.WaveAudio).Should().BeOfType<MemoryStream>().Which.ToArray().Should().Equal(audioBytes);

System\Private\Windows\Ole\NativeToManagedAdapterTests.cs (2)

44result.ToArray().Should().Equal(0xBE, 0xAD); 350result.ToArray().Should().Equal(0xBE, 0xAD, 0xCA, 0xFE);

System.Private.Windows.Core.TestUtilities (1)

BinarySerialization.cs (1)

99return stream.ToArray();

System.Private.Xml (1)

System\Xml\Xsl\Runtime\XmlQueryStaticData.cs (1)

325data = dataStream.ToArray();

System.Resources.Extensions (1)

src\libraries\Common\src\System\Resources\ResourceWriter.cs (1)

589byte[] arr = ms.ToArray();

System.Resources.Writer (1)

src\libraries\Common\src\System\Resources\ResourceWriter.cs (1)

589byte[] arr = ms.ToArray();

System.Security.Cryptography (3)

src\libraries\Common\src\System\Net\Http\X509ResourceClient.cs (1)

264return result.ToArray();

System\Security\Cryptography\CapiHelper.DSA.Shared.cs (1)

140byte[] key = ms.ToArray();

System\Security\Cryptography\CapiHelper.Shared.cs (1)

139byte[] key = ms.ToArray();

System.Security.Cryptography.Pkcs (1)

Internal\Cryptography\PkcsHelpers.cs (1)

333return memoryStream.ToArray();

System.Security.Cryptography.Xml (2)

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

240cipherValue = ms.ToArray();

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

605Encoding.UTF8.GetString(ms.ToArray()));

System.ServiceModel.Federation (2)

System\ServiceModel\Federation\WSTrustChannelSecurityTokenProvider.cs (2)

241var reader = XmlDictionaryReader.CreateTextReader(memeoryStream.ToArray(), XmlDictionaryReaderQuotas.Max); 280var reader = XmlDictionaryReader.CreateTextReader(memeoryStream.ToArray(), XmlDictionaryReaderQuotas.Max);

System.Transactions.Local (1)

System\Transactions\TransactionManager.cs (1)

482returnValue = stream.ToArray();

System.Windows.Forms (5)

System\Resources\ResXDataNode.cs (1)

317nodeInfo.ValueData = ToBase64WrappedString(stream.ToArray());

System\Windows\Forms\ActiveX\AxHost.State.cs (2)

346info.AddValue(DataSerializationName, stream.ToArray()); 354info.AddValue(PropertyBagSerializationName, propertyBagBinaryStream.ToArray());

System\Windows\Forms\ActiveX\AxHost.StateConverter.cs (1)

57return memoryStream.ToArray();

System\Windows\Forms\Input\Cursor.cs (1)

104_cursorData = memoryStream.ToArray();

System.Windows.Forms.Tests (31)

System\Resources\ResXFileRef.ConverterTests.cs (1)

96Assert.Equal(expected, Encoding.Default.GetString(result.ToArray()));

System\Resources\ResXResourceWriterTests.cs (1)

32byte[] buffer = stream.ToArray();

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

73Clipboard.GetAudioStream().Should().BeOfType<MemoryStream>().Which.ToArray().Should().Equal(audioBytes); 74Clipboard.GetData(DataFormats.WaveAudio).Should().BeOfType<MemoryStream>().Which.ToArray().Should().Equal(audioBytes); 105Clipboard.GetAudioStream().Should().BeOfType<MemoryStream>().Which.ToArray().Should().Equal(audioBytes); 106Clipboard.GetData(DataFormats.WaveAudio).Should().BeOfType<MemoryStream>().Which.ToArray().Should().Equal(audioBytes); 1135byte[] array = stream.ToArray();

System\Windows\Forms\DataObjectTests.cs (3)

1054dataObject.GetAudioStream().Should().BeOfType<MemoryStream>().Subject.ToArray().Should().BeEquivalentTo(audioBytes); 1055dataObject.GetData(DataFormats.WaveAudio, autoConvert: true).Should().BeOfType<MemoryStream>().Subject.ToArray().Should().Equal(audioBytes); 1056dataObject.GetData(DataFormats.WaveAudio, autoConvert: false).Should().BeOfType<MemoryStream>().Subject.ToArray().Should().Equal(audioBytes);

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

25string msBase64 = Convert.ToBase64String(ms.ToArray());

System\Windows\Forms\RichTextBoxTests.cs (19)

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

539Assert.Equal(Html, Encoding.UTF8.GetString(documentStream.ToArray()));

Test.Utilities (2)

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

75return memoryStream.ToArray();

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

127return ImmutableArray.Create<byte>(stream.ToArray());

Text.Analyzers (2)

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

75return memoryStream.ToArray();

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

127return ImmutableArray.Create<byte>(stream.ToArray());

WsFedSample (1)

Program.cs (1)

54certificatePayload = memoryStream.ToArray();