Stream

docs\samples\Microsoft.ML.Samples\Dynamic\Trainers\MulticlassClassification\ImageClassification\LearningRateSchedulingCifarResnetTransferLearning.cs (1)

306var response = await client.GetStreamAsync(new Uri($"{url}")).ConfigureAwait(false);

docs\samples\Microsoft.ML.Samples\Dynamic\Trainers\MulticlassClassification\ImageClassification\ResnetV2101TransferLearningEarlyStopping.cs (1)

262var response = await client.GetStreamAsync(new Uri($"{url}")).ConfigureAwait(false);

docs\samples\Microsoft.ML.Samples\Dynamic\Trainers\MulticlassClassification\ImageClassification\ResnetV2101TransferLearningTrainTestSplit.cs (1)

283var response = await client.GetStreamAsync(new Uri($"{url}")).ConfigureAwait(false);

SamplesDatasetUtils.cs (1)

198var response = await client.GetStreamAsync(new Uri($"{baseGitPath}")).ConfigureAwait(false);

BytesStreamSource.cs (1)

38public Stream Open(int index)

ExpressionLanguageTests\ExpressionLanguageTests.cs (1)

98var stream = typeof(ExprLanguageTests).Assembly.GetManifestResourceStream(resName);

ImagesTests.cs (4)

85using (var fs = file.CreateWriteStream()) 88using (var fs = file.OpenReadStream()) 1379private Stream _stream; 1381public ReadOnlyNonSeekableStream(Stream stream) => _stream = stream;

TrainerEstimators\TreeEnsembleFeaturizerTest.cs (4)

621using (var fs = file.CreateWriteStream()) 624using (var fs = file.OpenReadStream()) 678using (var fs = file.CreateWriteStream()) 681using (var fs = file.OpenReadStream())

PredictionEngine.cs (2)

95/// Checkpoints <see cref="TimeSeriesPredictionEngine{TSrc, TDst}"/> to a <see cref="Stream"/> with the updated 108public void CheckPoint(IHostEnvironment env, Stream stream)

Model\BertTokenizer.cs (4)

678Stream vocabStream, 693Stream vocabStream, 722Stream stream = string.IsNullOrEmpty(vocabFilePath) ? throw new ArgumentNullException(nameof(vocabFilePath)) : File.OpenRead(vocabFilePath); 734private static BertTokenizer Create(Stream vocabStream, BertOptions? options, bool disposeStream)

Model\BPETokenizer.cs (11)

126using Stream vocabStream = File.OpenRead(vocabFile); 127using Stream? mergesStream = mergesFile is null ? null : File.OpenRead(mergesFile); 142public static BpeTokenizer Create(Stream vocabStream, Stream? mergesStream) 161Stream vocabStream, 162Stream? mergesStream, 197Stream vocabStream, 198Stream? mergesStream, 773internal static async ValueTask<(Dictionary<StringSpanOrdinalKey, int>?, Vec<(string, string)>)> ReadModelDataAsync(Stream vocab, Stream? merges, bool useAsync, CancellationToken cancellationToken = default) 808internal static async ValueTask<Vec<(string, string)>> ConvertMergesToHashmapAsync(Stream? mergesStream, bool useAsync = false, CancellationToken cancellationToken = default)

Model\CodeGenTokenizer.cs (8)

85Stream vocabularyStream, 86Stream mergeStream, 100private CodeGenTokenizer(Stream vocabularyStream, Stream mergeStream, PreTokenizer? preTokenizer, Normalizer? normalizer, IReadOnlyDictionary<string, int>? specialTokens, bool addPrefixSpace, 1765private static Dictionary<StringSpanOrdinalKey, (int, string)> GetVocabulary(Stream vocabularyStream) 1785internal static Dictionary<StringSpanOrdinalKeyPair, int> GetMergeRanks(Stream mergeStream) 1878Stream vocabStream, 1879Stream mergesStream,

Model\EnglishRobertaTokenizer.cs (17)

Model\LlamaTokenizer.cs (1)

35Stream modelStream,

Model\Phi2Tokenizer.cs (4)

66Stream vocabularyStream, 67Stream mergeStream, 100Stream vocabStream, 101Stream mergesStream,

Model\TiktokenTokenizer.cs (10)

61internal TiktokenTokenizer(Stream vocabStream, PreTokenizer? preTokenizer, IReadOnlyDictionary<string, int>? specialTokens = null, Normalizer? normalizer = null, int cacheSize = LruCache<int[]>.DefaultCacheSize) : 102private TiktokenTokenizer(Stream vocabStream, PreTokenizer? preTokenizer, IReadOnlyDictionary<string, int>? specialTokens, Normalizer? normalizer, int cacheSize, bool disposeStream) 158Stream vocabStream, bool useAsync, CancellationToken cancellationToken = default) 1228using Stream compressedStream = tiktokenConfiguration.DataType.Assembly!.GetManifestResourceStream(tiktokenConfiguration.VocabFile)!; 1229using Stream deflateStream = new DeflateStream(compressedStream, CompressionMode.Decompress); 1279Stream vocabStream, 1300Stream vocabStream, 1344using Stream vocabStream = File.OpenRead(vocabFilePath); 1359Stream vocabStream, 1398Stream vocabStream,

Model\WordPieceTokenizer.cs (5)

92internal static async ValueTask<(Dictionary<StringSpanOrdinalKey, int>, Dictionary<int, string>)> LoadVocabAsync(Stream vocabStream, bool useAsync, CancellationToken cancellationToken = default) 147Stream vocabStream, 152Stream vocabStream, 209Stream vocabStream, 215Stream vocabStream,

Utils\Helpers.netstandard.cs (2)

23public static async Task<Stream> GetStreamAsync(HttpClient client, string url, CancellationToken cancellationToken = default) 30public static Stream GetStream(HttpClient client, string url) => client.GetStreamAsync(url).GetAwaiter().GetResult();

test\Microsoft.ML.Tokenizers.Tests\Utils.cs (2)

24var stream = await response.Content.ReadAsStreamAsync(); 58using Stream fileStream = File.Create(fileName);

BertTokenizerTests.cs (8)

41using Stream vocabStream = File.OpenRead(vocabFile); 112using Stream vocabStream = File.OpenRead(vocabFile); 183using Stream vocabStream = File.OpenRead(vocabFile); 234using Stream vocabStream = File.OpenRead(vocabFile); 309using Stream vocabStream = File.OpenRead(vocabFile); 362using Stream vocabStream = File.OpenRead(vocabFile); 462using Stream vocabStream = File.OpenRead(vocabFile); 555using Stream vocabStream = File.OpenRead(vocabFile);

BpeTests.cs (6)

331using Stream vocabStream = File.OpenRead(Path.Combine(@"Gpt-2", "vocab.json")); 332using Stream mergesStream = File.OpenRead(Path.Combine(@"Gpt-2", "merges.txt")); 351using Stream vocabStream = File.OpenRead(vocabFile); 352using Stream mergesStream = File.OpenRead(mergesFile); 500using Stream vocabStream = File.OpenRead(Path.Combine(@"Gpt-2", "vocab.json")); 501using Stream mergesStream = File.OpenRead(Path.Combine(@"Gpt-2", "merges.txt"));

CodeGenTests.cs (4)

28using Stream vocabStream = File.OpenRead(Path.Combine(@"Codegen-350M-mono", "vocab.json")); 29using Stream mergesStream = File.OpenRead(Path.Combine(@"Codegen-350M-mono", "merges.txt")); 39using Stream vocabStream = File.OpenRead(Path.Combine(@"Phi-2", "vocab.json")); 40using Stream mergesStream = File.OpenRead(Path.Combine(@"Phi-2", "merges.txt"));

EnglishRobertaTests.cs (3)

122using Stream vocabStream = File.OpenRead(vocabFile); 123using Stream mergeStream = File.OpenRead(mergeFile); 124using Stream translationStream = File.OpenRead(translationFile);

LlamaTests.cs (3)

32using Stream remoteStream = File.OpenRead(Path.Combine(@"Llama", "tokenizer.model")); 39using Stream remoteStream = File.OpenRead(Path.Combine(@"Mistral", "tokenizer.model")); 46using Stream remoteStream = File.OpenRead(Path.Combine(@"Llama", "tokenizer.model"));

TiktokenTests.cs (13)

Utils.cs (2)

24var stream = await response.Content.ReadAsStreamAsync(); 58using Stream fileStream = File.Create(fileName);

WordPieceTests.cs (1)

32using Stream vocabStream = File.OpenRead(vocabFile);

Utils\FileUtils.cs (1)

42public static IEnumerable<T> LoadNumberArrayFromStream<T>(Stream stream, int numElements, int tSize)

MissingValueReplacing.cs (2)

485private void WriteTypeAndValue<T>(Stream stream, BinarySaver saver, DataViewType type, T rep) 518Action<Stream, BinarySaver, DataViewType, int> func = WriteTypeAndValue<int>;

SvmLight\SvmLightLoaderSaverCatalog.cs (1)

122Stream stream,

SvmLight\SvmLightSaver.cs (1)

87public void SaveData(Stream stream, IDataView data, params int[] cols)

Text\StopWordsRemovingTransformer.cs (2)

325Stream stopWordsStream = GetResourceFileStreamOrNull(lang); 341private static Stream GetResourceFileStreamOrNull(StopWordsRemovingEstimator.Language lang)

ImageClassificationTrainer.cs (8)

887using Stream featuresWriter = File.Open(cacheFilePath + "_features.bin", FileMode.Create); 888using Stream labelWriter = File.Open(cacheFilePath + "_labels.bin", FileMode.Create); 929using (Stream trainSetLabelReader = File.Open(trainBottleneckFilePath + "_labels.bin", FileMode.Open)) 930using (Stream trainSetFeatureReader = File.Open(trainBottleneckFilePath + "_features.bin", FileMode.Open)) 932Stream validationSetLabelReader = validationNeeded ? 935Stream validationSetFeatureReader = validationNeeded ? 1081long[] labelTensorShape, long[] featureTensorShape, int batchSize, Stream trainSetLabelReader, 1082Stream trainSetFeatureReader, byte[] labelBufferBytes, byte[] featuresBufferBytes,

Microsoft\VisualBasic\CompilerServices\VB6RandomFile.vb (1)

59Dim stm As Stream

Microsoft\VisualBasic\FileIO\TextFieldParser.vb (5)

65Public Sub New(ByVal stream As Stream) 77Public Sub New(ByVal stream As Stream, ByVal defaultEncoding As System.Text.Encoding) 90Public Sub New(ByVal stream As Stream, ByVal defaultEncoding As System.Text.Encoding, ByVal detectEncoding As Boolean) 103Public Sub New(ByVal stream As Stream, ByVal defaultEncoding As System.Text.Encoding, ByVal detectEncoding As Boolean, ByVal leaveOpen As Boolean) 569Private Sub InitializeFromStream(ByVal stream As Stream, ByVal defaultEncoding As System.Text.Encoding, ByVal detectEncoding As Boolean)

Microsoft\VisualBasic\Devices\Audio.vb (2)

127''' Plays a <see cref="Stream"/> representation of a .wav file in the passed in <see cref="AudioPlayMode"/>. 132Public Sub Play(stream As Stream, playMode As AudioPlayMode)

Microsoft\VisualBasic\Logging\FileLogTraceListener.ReferencedStream.vb (8)

Microsoft\VisualBasic\Logging\FileLogTraceListener.vb (8)

Microsoft\VisualBasic\MyServices\ClipboardProxy.vb (4)

89''' <returns>The audio stream as a <see cref="Stream"/>.</returns> 90Public Function GetAudioStream() As Stream 164''' <param name="audioStream">The <see cref="Stream"/> to be saved.</param> 165Public Sub SetAudio(audioStream As Stream)

ColorSchemes\ColorSchemeApplier.ColorSchemeReader.cs (1)

25public static ColorScheme ReadColorScheme(Stream schemeStream)

ColorSchemes\ColorSchemeApplier.Settings.cs (2)

52using var colorSchemeStream = GetColorSchemeXmlStream(schemeName); 56private static Stream GetColorSchemeXmlStream(ColorSchemeName schemeName)

ProjectSystem\MetadataReferences\VisualStudioMetadataReferenceManager.cs (2)

248static void StreamCopy(Stream source, Stream destination, int start, int length)

RoslynPackage.cs (2)

114protected override void OnLoadOptions(string key, Stream stream) 132protected override void OnSaveOptions(string key, Stream stream)

Storage\FileDownloader.cs (1)

62public Task<Stream?> ReadFileAsync()

PersistentStorage\AbstractPersistentStorageTests.cs (2)

1062protected Stream EncodeString(string text) 1069private string ReadStringToEnd(Stream? stream)

SymbolSearch\SymbolSearchUpdateEngineTests.vb (4)

645Private Shared Function CreateDownloaderMock(stream As Stream) As Mock(Of IFileDownloader) 664Optional contents As String = Nothing) As Stream 673Private Shared Function CreateFullDownloadElementStream() As Stream 684Private Shared Function CreateStream(element As XElement) As Stream

BufferedReadStream.cs (2)

14private Stream _innerStream; 21public BufferedReadStream(Stream innerStream)

CachingFileSystemWrapper.cs (1)

59public Stream GetFileStream(string path, FileMode mode, FileAccess access, FileShare share)

CommunicationsUtilities.cs (1)

588internal static async Task<int> ReadAsync(Stream stream, byte[] buffer, int bytesToRead)

FileUtilities.cs (3)

1409Stream fileStream = new FileStream(path, mode, FileAccess.Write, FileShare.Read, DefaultFileStreamBufferSize, FileOptions.SequentialScan); 1423Stream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, DefaultFileStreamBufferSize, FileOptions.SequentialScan); 1533internal static void ReadFromStream(this Stream stream, byte[] content, int startIndex, int length)

IFileSystem.cs (1)

27Stream GetFileStream(string path, FileMode mode, FileAccess access, FileShare share);

InterningBinaryReader.cs (4)

61private InterningBinaryReader(Stream input, Buffer buffer, bool isPrivateBuffer) 243private static BinaryReader Create(Stream stream, BinaryReaderFactory sharedBuffer) 292public override BinaryReader Create(Stream stream) 305public override BinaryReader Create(Stream stream)

ManagedFileSystem.cs (1)

42public Stream GetFileStream(string path, FileMode mode, FileAccess access, FileShare share)

MSBuildOnWindowsFileSystem.cs (1)

31public Stream GetFileStream(string path, FileMode mode, FileAccess access, FileShare share)

NodeEndpointOutOfProcBase.cs (2)

514private void RunReadLoop(Stream localReadPipe, Stream localWritePipe,

PerformanceLogEventListener.cs (1)

87Stream outputStream = new FileStream(

BinaryReaderFactory.cs (1)

13public abstract BinaryReader Create(Stream stream);

BinaryTranslator.cs (6)

38internal static ITranslator GetReadTranslator(Stream stream, BinaryReaderFactory buffer) 49internal static ITranslator GetWriteTranslator(Stream stream) 62private Stream _packetStream; 73public BinaryReadTranslator(Stream packetStream, BinaryReaderFactory buffer) 818private Stream _packetStream; 829public BinaryWriteTranslator(Stream packetStream)

BufferedReadStream.cs (2)

14private Stream _innerStream; 21public BufferedReadStream(Stream innerStream)

FileSystem\MSBuildTaskHostFileSystem.cs (1)

51public Stream GetFileStream(string path, FileMode mode, FileAccess access, FileShare share)

FileUtilities.cs (3)

1409Stream fileStream = new FileStream(path, mode, FileAccess.Write, FileShare.Read, DefaultFileStreamBufferSize, FileOptions.SequentialScan); 1423Stream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, DefaultFileStreamBufferSize, FileOptions.SequentialScan); 1533internal static void ReadFromStream(this Stream stream, byte[] content, int startIndex, int length)

IFileSystem.cs (1)

27Stream GetFileStream(string path, FileMode mode, FileAccess access, FileShare share);

InterningBinaryReader.cs (4)

61private InterningBinaryReader(Stream input, Buffer buffer, bool isPrivateBuffer) 243private static BinaryReader Create(Stream stream, BinaryReaderFactory sharedBuffer) 292public override BinaryReader Create(Stream stream) 305public override BinaryReader Create(Stream stream)

NodeEndpointOutOfProcBase.cs (2)

514private void RunReadLoop(Stream localReadPipe, Stream localWritePipe,

src\libraries\shims\mscorlib\ref\mscorlib.cs (1)

342[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.IO.Stream))]

netstandard.cs (1)

963[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.IO.Stream))]

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

42private Stream SourceStream

Microsoft\Build\Tasks\Windows\UidManager.cs (7)

245using (Stream uidStream = new FileStream(tempFile, FileMode.Create)) 247using (Stream source = File.OpenRead(inputFile.ItemSpec)) 299using (Stream uidStream = new FileStream(tempFile, FileMode.Create)) 301using (Stream source = File.OpenRead(inputFile.ItemSpec)) 480using (Stream xamlStream = File.OpenRead(fileName)) 931internal UidWriter(UidCollector collector, Stream source, Stream target)

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

499Stream bamlStream = null;

MS\Internal\MarkupCompiler\ParserExtension.cs (1)

35Stream xamlStream,

MS\Internal\Shared\SourceFileInfo.cs (2)

112internal Stream Stream 158private Stream _stream;

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

243Stream stream = _taskFileService.GetContent(_localCacheFile);

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

157Stream stream = null;

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

40Stream GetContent(string srcFile); 121public Stream GetContent(string srcFile) 123Stream fileStream; 200using (Stream fileStream = File.OpenRead(fileName))

src\Microsoft.DotNet.Wpf\src\PresentationFramework\System\Windows\Markup\BamlBinaryWriter.cs (1)

22public BamlBinaryWriter(Stream stream, Encoding code)

src\Microsoft.DotNet.Wpf\src\PresentationFramework\System\Windows\Markup\BamlRecordWriter.cs (3)

48Stream stream, 1814public Stream BamlStream 1891Stream _bamlStream;

src\Microsoft.DotNet.Wpf\src\PresentationFramework\System\Windows\Markup\XamlParser.cs (1)

70Stream xamlStream,

src\Microsoft.DotNet.Wpf\src\WindowsBase\System\IO\Packaging\CompoundFile\FormatVersion.cs (1)

292public int SaveToStream(Stream stream)

MS\Internal\AppModel\SiteOfOriginPart.cs (8)

46protected override Stream GetStreamCore(FileMode mode, FileAccess access) 82private Stream GetStreamAndSetContentType(bool onlyNeedContentType) 111Stream temp = _cacheStream; 141Stream responseStream; 155private Stream HandleFileSource(bool onlyNeedContentType) 176private Stream HandleWebSource(bool onlyNeedContentType) 179Stream responseStream = response.GetResponseStream(); 222Stream _cacheStream = null;

MS\Internal\FontCache\FontSource.cs (5)

176Stream fontStream; 229public Stream GetStream() 250Stream fontStream; 289private static byte [] StreamToByteArray(Stream fontStream) 354private Stream GetCompositeFontResourceStream()

MS\Internal\FontFace\CompositeFontParser.cs (3)

151internal static CompositeFontInfo LoadXml(Stream fileStream) 161private CompositeFontParser(Stream fileStream) 222private XmlReader CreateXmlReader(Stream fileStream)

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

44internal static void EncodeToStream(ExtendedProperty attribute, Stream stream) 76internal static void EncodeAttribute(Guid guid, object value, VarEnum type, Stream stream) 306internal static uint EncodeAsISF(Guid id, byte[] data, Stream strm, GuidList guidList, byte compressionAlgorithm, bool fTag) 405internal static uint DecodeAsISF(Stream stream, uint cbSize, GuidList guidList, KnownTagCache.KnownTagIndex tag, ref Guid guid, out object data) 504internal static object DecodeAttribute(Guid guid, Stream stream) 522internal static object DecodeAttribute(Guid guid, Stream memStream, out VarEnum type) 720internal static uint EncodeAsISF(ExtendedPropertyCollection attributes, Stream stream, GuidList guidList, byte compressionAlgorithm, bool fTag)

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

MS\Internal\Ink\InkSerializedFormat\GuidTagList.cs (2)

204public uint Save(Stream stream) 248public uint Load(Stream strm, uint size)

MS\Internal\Ink\InkSerializedFormat\InkSerializer.cs (25)

66internal void DecodeISF(Stream inkData) 196internal uint LoadStrokeIds(Stream isfStream, uint cbSize) 234private bool IsGIFData(Stream inkdata) 251private void ExamineStreamHeader(Stream inkdata, out bool fBase64, out bool fGif, out uint cbData) 292private void DecodeRawISF(Stream inputStream) 813private uint LoadDrawAttrsTable(Stream strm, GuidList guidList, uint cbSize) 874private uint DecodeStrokeDescriptor(Stream strm, uint cbSize, out StrokeDescriptor descr) 954private uint DecodeStrokeDescriptorBlock(Stream strm, uint cbSize) 978private uint DecodeStrokeDescriptorTable(Stream strm, uint cbSize) 1030private uint DecodeMetricTable(Stream strm, uint cbSize) 1080private uint DecodeMetricBlock(Stream strm, uint cbSize, out MetricBlock block) 1149private uint DecodeTransformTable(Stream strm, uint cbSize, bool useDoubles) 1205internal static uint ReliableRead(Stream stream, byte[] buffer, uint requestedCount) 1241private uint DecodeTransformBlock(Stream strm, KnownTagCache.KnownTagIndex tag, uint cbSize, bool useDoubles, out TransformDescriptor xform) 1323private uint DecodeInkSpaceRectangle(Stream strm, uint cbSize) 1673internal void EncodeISF(Stream outputStream) 1868private void StoreStrokeData(Stream localStream, GuidList guidList, ref uint cumulativeEncodedSize, ref uint localEncodedSize) 1993internal static uint SaveStrokeIds(StrokeCollection strokes, Stream strm, bool forceSave) 2086private bool IsBase64Data(Stream data) 2191private uint SerializePacketDescrTable(Stream strm) 2247private uint SerializeMetricTable(Stream strm) 2295private uint EncodeStrokeDescriptor(Stream strm, StrokeDescriptor strd) 2316private uint SerializeTransformTable(Stream strm) 2390private uint EncodeTransformDescriptor(Stream strm, TransformDescriptor xform, bool useDoubles) 2443private uint SerializeDrawingAttrsTable(Stream stream, GuidList guidList)

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

501public uint Pack(Stream strm)

MS\Internal\Ink\InkSerializedFormat\SerializationHelper.cs (6)

41public static uint Encode(Stream strm, uint Value) 66public static uint EncodeLarge(Stream strm, ulong ulValue) 95public static uint SignEncode(Stream strm, int Value) 125public static uint Decode(Stream strm, out uint dw) 150public static uint DecodeLarge(Stream strm, out ulong ull) 178public static uint SignDecode(Stream strm, out int i)

MS\Internal\Ink\InkSerializedFormat\StrokeSerializer.cs (6)

47internal static uint DecodeStroke(Stream stream, 125Stream stream, 344static uint LoadPackets(Stream inputStream, 655Stream stream, 799Stream stream, 940Stream stream,

MS\Internal\IO\Packaging\ByteRangeDownloader.cs (4)

71internal ByteRangeDownloader(Uri requestedUri, Stream tempStream, SafeWaitHandle eventHandle, Mutex fileMutex) 588private bool Write(Stream s, int offset, int length) 625using (Stream s = response.GetResponseStream()) 854private System.IO.Stream _tempFileStream; // stream to write to

MS\Internal\IO\Packaging\DeobfuscatingStream.cs (2)

195internal DeobfuscatingStream(Stream obfuscatedStream, Uri streamUri, bool leaveOpen) 353private Stream _obfuscatedStream; // stream we ultimately decompress from and to in the container

MS\Internal\IO\Packaging\NetStream.cs (4)

69Stream responseStream, 488ObjectDisposedException.ThrowIf(_disposed, typeof(Stream)); 1267Stream _tempFileStream; // local temp stream we are writing to and reading from - protected by _tempFileMutex 1289private Stream _responseStream; // Stream returned by WebResponse

MS\Internal\IO\Packaging\PseudoWebRequest.cs (1)

71public override Stream GetRequestStream()

MS\Internal\IO\Packaging\ResponseStream.cs (7)

45internal ResponseStream(Stream s, PackWebResponse response, Stream owningStream, System.IO.Packaging.Package container) 57internal ResponseStream(Stream s, PackWebResponse response) 69private void Init(Stream s, PackWebResponse response, Stream owningStream, System.IO.Packaging.Package container) 272private Stream _innerStream; // stream we are emulating 274private Stream _owningStream; // stream under the _innerStream when opening a Part

MS\Internal\Resources\ResourceManagerWrapper.cs (3)

40internal Stream GetStream(string name) 42Stream stream = null; 76stream = this.ResourceSet.GetObject(name) as Stream;

MS\Internal\SystemDrawingHelper.cs (3)

87internal static Stream GetCommentFromGifStream(Stream stream) 94internal static void SaveMetafileToImageStream(MemoryStream metafileStream, Stream imageStream)

MS\Internal\WpfWebRequestHelper.cs (4)

160internal static Stream CreateRequestAndGetResponseStream(Uri uri) 165internal static Stream CreateRequestAndGetResponseStream(Uri uri, out ContentType contentType) 213internal static Stream GetResponseStream(WebRequest request) 222internal static Stream GetResponseStream(WebRequest request, out ContentType contentType)

src\Microsoft.DotNet.Wpf\src\Shared\MS\Internal\IO\SynchronizingStream.cs (3)

34internal SynchronizingStream(Stream stream, Object syncRoot) 269ObjectDisposedException.ThrowIf(_baseStream is null, typeof(Stream)); 277private Stream _baseStream; // stream we are wrapping

System\IO\Packaging\PackWebRequest.cs (1)

100public override Stream GetRequestStream()

System\IO\Packaging\PackWebResponse.cs (5)

161public override Stream GetResponseStream() 238Stream s = p.GetSeekableStream(FileMode.Open, FileAccess.Read); 594internal Stream GetResponseStream() 632Stream s = p.GetSeekableStream(FileMode.Open, FileAccess.Read); 929private Stream _responseStream; // mimic existing Response behavior by creating and returning

System\Windows\BinaryFormat\BinaryFormatWriter.cs (27)

System\Windows\BinaryFormat\BinaryFormatWriterScope.cs (1)

14public BinaryFormatWriterScope(Stream stream)

System\Windows\clipboard.cs (3)

160public static Stream GetAudioStream() 162return GetDataInternal(DataFormats.WaveAudio) as Stream; 250public static void SetAudio(Stream audioStream)

System\Windows\dataobject.cs (13)

384public Stream GetAudioStream() 386return GetData(DataFormats.WaveAudio, /*autoConvert*/false) as Stream; 459public void SetAudio(Stream audioStream) 1455if (data is Stream) 1457hr = SaveStreamToHandle(medium.unionmember, (Stream)data, doNotReallocate); 1561Stream inkStream = data as Stream; 1658Stream stream; 1695private int SaveStreamToHandle(IntPtr handle, Stream stream, bool doNotReallocate) 1738Stream bitmapStream; 2937private Stream ReadByteStreamFromHandle(IntPtr handle, out bool isSerializedObject) 3000Stream stream; 3057Stream bitmapStream;

System\Windows\Ink\StrokeCollection.cs (7)

56public StrokeCollection(Stream stream) 64Stream seekableStream = GetSeekableStream(stream); 80public virtual void Save(Stream stream, bool compress) 92public void Save(Stream stream) 100internal void SaveIsf(Stream stream, bool compress) 112private Stream GetSeekableStream(Stream stream)

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

130ConstructorInfo ci = typeof(StrokeCollection).GetConstructor(new Type[] { typeof(Stream) });

System\Windows\Input\Cursor.cs (4)

72public Cursor(Stream cursorStream):this(cursorStream, false) 81public Cursor(Stream cursorStream, bool scaleWithDpi) 209private void LegacyLoadFromStream(Stream cursorStream) 273private void LoadFromStream(Stream cursorStream)

System\Windows\Media\ColorContext.cs (3)

206public Stream OpenProfileStream() 494Stream profileStream = null; 574private void FromStream(Stream stm, string filename)

System\Windows\Media\Effects\PixelShader.cs (3)

16public void SetStreamSource(Stream source) 72Stream stream = null; 109private void LoadPixelShaderFromStreamIntoMemory(Stream source)

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

257public Stream GetFontStream()

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

31if (sourceType == typeof(string) || sourceType == typeof(Stream) || sourceType == typeof(Uri) || sourceType == typeof(byte[])) 108Stream memStream = null; 130else if (value is Stream stream) 213private unsafe Stream GetBitmapStream(byte[] rawData)

System\Windows\Media\Imaging\BitmapDecoder.cs (23)

109Stream bitmapStream, 157Stream stream, 162Stream uriStream, 222Stream stream, 234Stream uriStream = null; 483Stream bitmapStream, 990Stream stream, 994out Stream uriStream, 1001System.IO.Stream bitmapStream = null; 1028if ((bitmapStream == null) || (bitmapStream == System.IO.Stream.Null)) 1184private static Stream ProcessHttpsFiles(Uri uri, Stream stream) 1186Stream bitmapStream = stream; 1202private static Stream ProcessHttpFiles(Uri uri, Stream stream) 1205Stream bitmapStream = stream; 1217private static Stream ProcessUncFiles(Uri uri) 1276private static System.IO.Stream GetSeekableStream(System.IO.Stream bitmapStream) 1495private static IntPtr GetIStreamFromStream(ref System.IO.Stream bitmapStream) 1539bitmapStream = System.IO.Stream.Null; 1631internal Stream _stream; 1640internal Stream _uriStream;

System\Windows\Media\Imaging\BitmapDownload.cs (3)

28internal Stream inputStream; 29internal Stream outputStream; 73Stream stream

System\Windows\Media\Imaging\BitmapEncoder.cs (1)

315public virtual void Save(System.IO.Stream stream)

System\Windows\Media\Imaging\BitmapFrame.cs (3)

41Stream stream, 172Stream bitmapStream 195Stream bitmapStream,

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

648_streamSource = e.NewValue as Stream; 908private Stream _streamSource;

System\Windows\Media\Imaging\BmpBitmapDecoder.cs (3)

49Stream bitmapStream, 64Stream stream, 69Stream uriStream,

System\Windows\Media\Imaging\Generated\BitmapImage.cs (4)

178public Stream StreamSource 182return (Stream) GetValue(StreamSourceProperty); 463internal static Stream s_StreamSource = null; 514typeof(Stream),

System\Windows\Media\Imaging\GifBitmapDecoder.cs (3)

49Stream bitmapStream, 64Stream stream, 69Stream uriStream,

System\Windows\Media\Imaging\IconBitmapDecoder.cs (3)

49Stream bitmapStream, 64Stream stream, 69Stream uriStream,

System\Windows\Media\Imaging\JpegBitmapDecoder.cs (3)

49Stream bitmapStream, 64Stream stream, 69Stream uriStream,

System\Windows\Media\Imaging\LateBoundBitmapDecoder.cs (3)

28Stream stream, 288Stream newStream = (Stream)arg;

System\Windows\Media\Imaging\PngBitmapDecoder.cs (3)

49Stream bitmapStream, 64Stream stream, 69Stream uriStream,

System\Windows\Media\Imaging\TiffBitmapDecoder.cs (3)

49Stream bitmapStream, 64Stream stream, 69Stream uriStream,

System\Windows\Media\Imaging\UnknownBitmapDecoder.cs (2)

54Stream stream, 59Stream uriStream,

System\Windows\Media\Imaging\WmpBitmapDecoder.cs (3)

49Stream bitmapStream, 64Stream stream, 69Stream uriStream,

System\Windows\Media\StreamAsIStream.cs (3)

120protected System.IO.Stream dataStream; 128private StreamAsIStream(System.IO.Stream dataStream) 629internal static IntPtr IStreamFrom(System.IO.Stream stream)

TestUtilities\BinaryFormatTestExtensions.cs (1)

21public static Stream Serialize(this object source)

Microsoft\Win32\OpenFileDialog.cs (4)

64public Stream OpenFile() 85public Stream[] OpenFiles() 93Stream[] streams = new Stream[cachedFileNames.Length];

Microsoft\Win32\SaveFileDialog.cs (1)

63public Stream OpenFile()

MS\Internal\AppModel\AppModelKnownContentFactory.cs (6)

28internal static object BamlConverter(Stream stream, Uri baseUri, bool canUseTopLevelBrowser, bool sandboxExternalContent, bool allowAsync, bool isJournalNavigation, out XamlReader asyncObjectConverter) 33internal static object BamlConverterCore(Stream stream, Uri baseUri, bool canUseTopLevelBrowser, bool sandboxExternalContent, bool allowAsync, bool isJournalNavigation, out XamlReader asyncObjectConverter, bool isUnsafe) 68internal static object XamlConverter(Stream stream, Uri baseUri, bool canUseTopLevelBrowser, bool sandboxExternalContent, bool allowAsync, bool isJournalNavigation, out XamlReader asyncObjectConverter) 73internal static object XamlConverterCore(Stream stream, Uri baseUri, bool canUseTopLevelBrowser, bool sandboxExternalContent, bool allowAsync, bool isJournalNavigation, out XamlReader asyncObjectConverter, bool isUnsafe) 130internal static object HtmlXappConverter(Stream stream, Uri baseUri, bool canUseTopLevelBrowser, bool sandboxExternalContent, bool allowAsync, bool isJournalNavigation, out XamlReader asyncObjectConverter) 135internal static object HtmlXappConverterCore(Stream stream, Uri baseUri, bool canUseTopLevelBrowser, bool sandboxExternalContent, bool allowAsync, bool isJournalNavigation, out XamlReader asyncObjectConverter, bool isUnsafe)

MS\Internal\AppModel\BamlStream.cs (2)

31internal BamlStream(Stream stream, Assembly assembly) 273private Stream _stream = null;

MS\Internal\AppModel\ContentFilePart.cs (3)

47protected override Stream GetStreamCore(FileMode mode, FileAccess access) 49Stream stream = null; 122private Stream CriticalOpenFile(string filename)

MS\Internal\AppModel\MimeObjectFactory.cs (5)

16internal delegate object StreamToObjectFactoryDelegate(Stream s, Uri baseUri, bool canUseTopLevelBrowser, bool sandboxExternalContent, bool allowAsync, bool isJournalNavigation, out XamlReader asyncObjectConverter); 17internal delegate object StreamToObjectFactoryDelegateCore(Stream s, Uri baseUri, bool canUseTopLevelBrowser, bool sandboxExternalContent, bool allowAsync, bool isJournalNavigation, out XamlReader asyncObjectConverter, bool isUnsafe); 30internal static object GetObjectAndCloseStream(Stream s, ContentType contentType, Uri baseUri, bool canUseTopLevelBrowser, bool sandboxExternalContent, bool allowAsync, bool isJournalNavigation, out XamlReader asyncObjectConverter) 35internal static object GetObjectAndCloseStreamCore(Stream s, ContentType contentType, Uri baseUri, bool canUseTopLevelBrowser, bool sandboxExternalContent, bool allowAsync, bool isJournalNavigation, out XamlReader asyncObjectConverter, bool isUnsafe) 60StreamToObjectFactoryDelegateCore methodCore = new StreamToObjectFactoryDelegateCore((Stream s, Uri baseUri, bool canUseTopLevelBrowser, bool sandboxExternalContent, bool allowAsync, bool isJournalNavigation, out XamlReader asyncObjectConverter, bool isUnsafe) => method(s, baseUri, canUseTopLevelBrowser, sandboxExternalContent, allowAsync, isJournalNavigation, out asyncObjectConverter));

MS\Internal\AppModel\ResourcePart.cs (4)

48protected override Stream GetStreamCore(FileMode mode, FileAccess access) 50Stream stream = null; 100private Stream EnsureResourceLocationSet() 102Stream stream = null;

MS\Internal\Globalization\BamlResourceDeserializer.cs (2)

25internal static BamlTree LoadBaml(Stream bamlStream) 46private BamlTree LoadBamlImp(Stream bamlSteam)

MS\Internal\Globalization\BamlResourceSerializer.cs (2)

22internal static void Serialize(BamlLocalizer localizer, BamlTree tree, Stream output) 49Stream output

MS\Internal\Ink\ISFClipboardData.cs (1)

83if ( stream != null && stream != Stream.Null )

MS\Internal\IO\Packaging\ManagedIStream.cs (2)

27internal ManagedIStream(Stream ioStream) 225private Stream _ioStream;

MS\Internal\IO\Packaging\PackageFilter.cs (1)

671private Stream _currentStream; //defaults to null

MS\Internal\IO\Packaging\XamlFilter.cs (2)

98internal XamlFilter(Stream stream) 1010private Stream _xamlStream;

MS\Internal\IO\Packaging\XpsFilter.cs (3)

634private static Stream FileToStream( 643Stream s = new FileStream(filePath, fileMode, fileAccess, fileSharing); 703private Stream _packageStream;

MS\Internal\Navigation\BindStream.cs (3)

28internal BindStream(Stream stream, long maxBytes, 423public Stream Stream 459Stream _stream;

System\Windows\Annotations\AnnotationDocumentPaginator.cs (2)

38public AnnotationDocumentPaginator(DocumentPaginator originalPaginator, Stream annotationStore) : this(originalPaginator, new XmlStreamStore(annotationStore), FlowDirection.LeftToRight) 48public AnnotationDocumentPaginator(DocumentPaginator originalPaginator, Stream annotationStore, FlowDirection flowDirection) : this(originalPaginator, new XmlStreamStore(annotationStore), flowDirection)

System\Windows\Annotations\Storage\XmlStreamStore.cs (4)

62public XmlStreamStore(Stream stream) 90public XmlStreamStore(Stream stream, IDictionary<Uri, IList<Uri>> knownNamespaces) 990private void SetStream(Stream stream, IDictionary<Uri, IList<Uri>> knownNamespaces) 1028private Stream _stream;

System\Windows\Application.cs (7)

374Stream stream = null; // stream could be extracted from the manifest resource or cached in the 473Stream stream = part.GetSeekableStream(); 511internal static object LoadBamlStreamWithSyncInfo(Stream stream, ParserContext pc) 672Stream stream = null; 2503internal NestedBamlLoadInfo(Uri uri, Stream stream, bool bSkipJournalProperty) 2524internal Stream BamlStream 2546private Stream _BamlStream = null;

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

747System.IO.Stream stream = null;

System\Windows\Controls\SoundPlayerAction.cs (8)

158Stream result = WpfWebRequestHelper.CreateRequestAndGetResponseStream(m_lastRequestedAbsoluteUri); 164private delegate Stream LoadStreamCaller(Uri uri); 169private Stream LoadStreamAsync(Uri uri) 178private void LoadStreamCallback(Stream asyncResult) 192Stream newStream = (Stream)asyncResultArg; 204m_player = new SoundPlayer((Stream)newStream); 208m_player.Stream = (Stream)newStream;

System\Windows\Controls\WebBrowser.cs (3)

153public void NavigateToStream(Stream stream) 665internal Stream DocumentStream 991private Stream _documentStream;

System\Windows\Data\XmlDataProvider.cs (1)

575Stream stream = response.GetResponseStream();

System\Windows\DeferrableContent.cs (2)

15internal Stream Stream 30internal DeferrableContent(Stream stream, Baml2006SchemaContext schemaContext,

System\Windows\DeferrableContentConverter.cs (3)

18if (typeof(Stream).IsAssignableFrom(sourceType) || sourceType == typeof(byte[])) 53Stream stream = value as Stream;

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

269Stream docStream = null;

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

927Stream pageStream = null;

System\Windows\Documents\FixedFindEngine.cs (2)

341using Stream pageStream = pageContent.GetPageStream(); 361private static String _ConstructPageString(Stream pageStream, bool reverseRTL)

System\Windows\Documents\FixedSchema.cs (2)

26public XmlEncodingEnforcingTextReader(Stream objectStream) 70Stream objectStream,

System\Windows\Documents\ITextRange.cs (2)

144void Save(Stream stream, string dataFormat); 170void Save(Stream stream, string dataFormat, bool preserveTextElements);

System\Windows\Documents\PageContent.cs (6)

362internal Stream GetPageStream() 365Stream pageStream = null; 514Stream pageStream; 574Stream pageStream = (Stream)_pendingStreams[sender]; 580internal static void _LoadPageImpl(Uri baseUri, Uri uriToLoad, out FixedPage fixedPage, out Stream pageStream)

System\Windows\Documents\PageContentAsyncResult.cs (2)

146Stream responseStream; 262private Stream _pendingStream;

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

252internal void WriteImageData(Stream imageStream, bool isBinary)

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

8651Stream imageStream = _wpfPayload.CreateImageStream(_imageCount, contentType, out imagePartUriString);

System\Windows\Documents\Serialization\ISerializerFactory.cs (1)

25SerializerWriter CreateSerializerWriter(Stream stream);

System\Windows\Documents\Serialization\SerializerProvider.cs (1)

121public SerializerWriter CreateSerializerWriter(SerializerDescriptor serializerDescriptor, Stream stream)

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

1608using (Stream sourceStream = WpfWebRequestHelper.CreateRequestAndGetResponseStream(resolvedUri))

System\windows\Documents\TextEditorCopyPaste.cs (3)

97Stream wpfContainerMemory = null; 418internal static string ConvertXamlToRtf(string xamlContent, Stream wpfContainerMemory) 440using (Stream xamlStream = wpfPayload.CreateXamlStream())

System\Windows\Documents\TextRange.cs (6)

198void ITextRange.Save(Stream stream, string dataFormat) 205void ITextRange.Save(Stream stream, string dataFormat, bool preserveTextElements) 933public void Save(Stream stream, string dataFormat) 967public void Save(Stream stream, string dataFormat, bool preserveTextElements) 998public void Load(Stream stream, string dataFormat) 1084internal virtual void LoadVirtual(Stream stream, string dataFormat)

System\Windows\Documents\TextRangeBase.cs (3)

1495internal static void Save(ITextRange thisRange, Stream stream, string dataFormat, bool preserveTextElements) 1526Stream wpfPayloadMemory = null; 1543internal static void Load(TextRange thisRange, Stream stream, string dataFormat)

System\windows\Documents\TextSelection.cs (1)

1339internal override void LoadVirtual(Stream stream, string dataFormat)

System\Windows\Documents\WpfPayload.cs (12)

160internal static string SaveRange(ITextRange range, ref Stream stream, bool useFlowDocumentAsRoot) 187internal static string SaveRange(ITextRange range, ref Stream stream, bool useFlowDocumentAsRoot, bool preserveTextElements) 216Stream xamlPartStream = xamlEntryPart.GetSeekableStream(); 256Stream xamlPartStream = xamlEntryPart.GetSeekableStream(); 298internal static object LoadElement(Stream stream) 469Stream imageStream = imagePart.GetSeekableStream(); 669internal Stream CreateXamlStream() 677internal Stream CreateImageStream(int imageCount, string contentType, out string imagePartUriString) 699internal Stream GetImageStream(string imageSourceString) 714private Package CreatePackage(Stream stream) 738internal static WpfPayload CreateWpfPayload(Stream stream) 759internal static WpfPayload OpenWpfPayload(Stream stream)

System\Windows\Documents\XamlToRtfWriter.cs (3)

2021using (Stream imageStream = _wpfPayload.GetImageStream(documentNode.FormatState.ImageSource)) 2044private void WriteShapeImage(DocumentNode documentNode, Stream imageStream, RtfImageFormat imageFormat) 2208private string ConvertToImageHexDataString(Stream imageStream)

System\Windows\Documents\XPSS0ValidatingLoader.cs (3)

31internal object Load(Stream stream, Uri parentUri, ParserContext pc, ContentType mimeType) 36internal void Validate(Stream stream, Uri parentUri, ParserContext pc, ContentType mimeType, string rootElement) 51private object Load(Stream stream, Uri parentUri, ParserContext pc, ContentType mimeType, string rootElement)

System\Windows\Markup\Baml2006\Baml2006Reader.cs (6)

60public Baml2006Reader(Stream stream) 70public Baml2006Reader(Stream stream, XamlReaderSettings xamlReaderSettings) 88internal Baml2006Reader(Stream stream, 99Stream stream, 108private void Initialize(Stream stream, 1109Stream s = _binaryReader.BaseStream;

System\Windows\Markup\Baml2006\Baml2006ReaderInternal.cs (2)

19internal Baml2006ReaderInternal(Stream stream, 26Stream stream,

System\Windows\Markup\Baml2006\BamlBinaryReader.cs (1)

11public BamlBinaryReader(Stream stream)

System\Windows\Markup\Baml2006\DeferredBinaryDeserializerExtension.cs (1)

19private readonly Stream _stream;

System\Windows\Markup\Baml2006\SharedStream.cs (5)

18private Stream _baseStream; 24public SharedStream(Stream baseStream) 37public SharedStream(Stream baseStream, long offset, long length) 44private void Initialize(Stream baseStream, long offset, long length) 274public Stream BaseStream

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

19public BamlBinaryReader(Stream stream, Encoding code)

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

22public BamlBinaryWriter(Stream stream, Encoding code)

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

156public BamlReader(Stream bamlStream)

System\Windows\Markup\BamlRecordReader.cs (10)

80Stream bamlStream, 88Stream bamlStream, 114Stream bamlStream, 176Stream stream = BinaryReader.BaseStream; 191Stream stream = BinaryReader.BaseStream; 296Stream stream = BinaryReader.BaseStream; 1030Stream bamlStream = BamlStream; 1679Stream stream = BinaryReader.BaseStream; 5377internal Stream BamlStream 5620Stream _bamlStream;

System\Windows\Markup\BamlRecordWriter.cs (3)

48Stream stream, 1814public Stream BamlStream 1891Stream _bamlStream;

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

27Stream stream)

System\Windows\Markup\Localizer\BamlLocalizer.cs (4)

28public BamlLocalizer(Stream source) : this (source, null) 38Stream source, 51Stream source, 79Stream target,

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

89if (!(source is byte[] || source is String || source is Stream))

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

83Stream xamlStream = new MemoryStream(UTF8Encoding.Default.GetBytes(xamlText)); 93public static object Load(Stream stream) 106public static object Load(Stream stream, bool useRestrictiveXamlReader) 144public static object Load(Stream stream, ParserContext parserContext) 158public static object Load(Stream stream, ParserContext parserContext, bool useRestrictiveXamlReader ) 182public object LoadAsync(Stream stream) 199public object LoadAsync(Stream stream, bool useRestrictiveXamlReader) 260public object LoadAsync(Stream stream, ParserContext parserContext) 278public object LoadAsync(Stream stream, ParserContext parserContext , bool useRestrictiveXamlReader) 1015Stream stream, 1174private Stream _stream;

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

97public static void Save(object obj, Stream stream)

System\Windows\Navigation\NavigationService.cs (2)

2853Stream s = response.GetResponseStream(); 2976private void DrainResponseStreamForPartialCacheFileBug(Stream s)

System\Windows\ResourceDictionary.cs (2)

171Stream s = null; 2625private Stream _bamlStream;

System\Windows\Resources\StreamResourceInfo.cs (3)

46public StreamResourceInfo(Stream stream, String contentType) 73public Stream Stream 89private Stream _stream;

System\Windows\SystemResources.cs (1)

902Stream stream = null;

SystemDrawingExtension.cs (4)

113internal override Stream GetCommentFromGifStream(Stream stream) 124internal override void SaveMetafileToImageStream(MemoryStream metafileStream, Stream imageStream) 138Stream bitmapStream;

MS\Internal\Documents\Application\Document.cs (3)

156internal abstract Stream Source 164internal abstract Stream Workspace 172internal abstract Stream Destination

MS\Internal\Documents\Application\DocumentManager.cs (1)

112Uri source, Stream stream)

MS\Internal\Documents\Application\DocumentStream.cs (2)

48Stream dataSource, 380internal static DocumentStream Open(Stream existing)

MS\Internal\Documents\Application\FileDocument.cs (1)

49public FileDocument(Stream existing)

MS\Internal\Documents\Application\PackageDocument.cs (3)

34internal override Stream Destination 46internal override Stream Source 58internal override Stream Workspace

MS\Internal\Documents\Application\RestrictedTransactionalPackage.cs (2)

37internal RestrictedTransactionalPackage(Stream original) 44internal override void MergeChanges(Stream target)

MS\Internal\Documents\Application\RightsController.cs (11)

39Stream ciphered = doc.Dependency.Workspace; 40Stream clear = ciphered; 107Stream ciphered = doc.Dependency.Source; 108Stream clear = ciphered; 195Stream ciphered = doc.Dependency.Source; 196Stream clear = ciphered; 294Stream ciphered = doc.Dependency.Destination; 295Stream clear = ciphered; 448private static EncryptedPackageEnvelope OpenEnvelopeOnStream(Stream ciphered) 466private static Stream DecryptEnvelopeAndSuppressStream( 470Stream clear = null;

MS\Internal\Documents\Application\RightsDocument.cs (2)

42Stream destinationStream = this.Dependency.Destination; 58Stream sourceStream = this.Dependency.Source;

MS\Internal\Documents\Application\RightsManagementSuppressedStream.cs (11)

30internal RightsManagementSuppressedStream(Stream targetOfProxy, bool isWriteAllowed) 44/// <see cref="System.IO.Stream"/> 55/// <see cref="System.IO.Stream"/> 71/// <see cref="System.IO.Stream"/> 79/// <see cref="System.IO.Stream"/> 87/// <see cref="System.IO.Stream"/> 98/// <see cref="System.IO.Stream"/> 114/// <see cref="System.IO.Stream"/> 122/// <see cref="System.IO.Stream"/> 130/// <see cref="System.IO.Stream"/> 140/// <see cref="System.IO.Stream"/>

MS\Internal\Documents\Application\StreamDocument.cs (3)

37internal override Stream Destination 54internal override Stream Source 71internal override Stream Workspace

MS\Internal\Documents\Application\StreamHelper.cs (2)

34internal static void CopyStream(Stream source, Stream target)

MS\Internal\Documents\Application\StreamProxy.cs (19)

MS\Internal\Documents\Application\TransactionalPackage.cs (6)

59internal TransactionalPackage(Stream original) 77internal void EnableEditMode(Stream workspace) 96internal virtual void MergeChanges(Stream target) 143internal void Rebind(Stream newOriginal) 478Stream source = original.GetStream(FileMode.Open, FileAccess.Read); 479Stream target = copy.GetStream(FileMode.Create, FileAccess.ReadWrite);

MS\Internal\Documents\Application\WriteableOnDemandPackagePart.cs (2)

140protected override System.IO.Stream GetStreamCore( 178private Stream WriteableStreamFactory(

MS\Internal\Documents\Application\WriteableOnDemandStream.cs (14)

MS\Internal\Documents\IRightsManagementProvider.cs (2)

127Stream DecryptPackage(); 134EncryptedPackageEnvelope EncryptPackage(Stream ciphered);

MS\Internal\Documents\RightsManagementManager.cs (2)

86internal Stream DecryptPackage() 99Stream returnPackage = null;

MS\Internal\Documents\RightsManagementProvider.cs (3)

568Stream IRightsManagementProvider.DecryptPackage() 576Stream result; 590EncryptedPackageEnvelope IRightsManagementProvider.EncryptPackage(Stream ciphered)

UpdateableFileProvider.cs (1)

100public Stream CreateReadStream()

Packaging\PartEditor.cs (4)

66internal Stream DataStream 128private Stream _partDataStream; 232Stream stream = MetroPart.GetStream(FileMode.Open); 250Stream stream = MetroPart.GetStream(FileMode.Create);

Packaging\XpsDocument.cs (3)

311using (Stream stream = part.GetStream(FileMode.Open, FileAccess.Read)) 813StreamContainsVersionExtensiblity( Stream stream ) 871Stream dataStream

Packaging\XpsFixedDocumentReaderWriter.cs (2)

943using (Stream stream = _metroPart.GetStream(FileMode.Open)) 1122using (Stream stream = sigDefPart.GetStream(FileMode.Create))

Packaging\XpsFixedDocumentSequenceReaderWriter.cs (1)

542using (Stream stream = _metroPart.GetStream(FileMode.Open))

Packaging\XpsManager.cs (2)

459Stream partDataStream; 509Stream stream = printTicketPart.GetStream(FileMode.Create);

Packaging\XpsResource.cs (1)

82Stream

PrintConfig\PrintCapabilitesWriter.cs (1)

25public PrintCapabilitiesWriter(Stream stream, string privateQname, string privateNamespace, bool indent)

PrintConfig\PrtCap_Builder.cs (1)

34public PrintCapBuilder(Stream xmlStream)

PrintConfig\PrtCap_Public.cs (1)

43public InternalPrintCapabilities(Stream xmlStream)

PrintConfig\PrtCap_Public_Simple.cs (3)

188/// <param name="xmlStream"><see cref="Stream"/> object containing the XML form of PrintCapabilities.</param> 193/// The <see cref="Stream"/> object specified by <paramref name="xmlStream"/> parameter doesn't contain a 198public PrintCapabilities(Stream xmlStream)

PrintConfig\PrtCap_Reader.cs (1)

34public XmlPrintCapReader(Stream xmlStream)

PrintConfig\PrtTicket_Public.cs (2)

62public InternalPrintTicket(Stream xmlStream) 150public void SaveTo(Stream outStream)

PrintConfig\PrtTicket_Public_Simple.cs (5)

257/// <param name="xmlStream"><see cref="Stream"/> object containing the XML form of PrintTicket.</param> 262/// The <see cref="Stream"/> object specified by <paramref name="xmlStream"/> parameter doesn't contain a 272public PrintTicket(Stream xmlStream) 307/// <param name="outStream">The <see cref="Stream"/> object to which you want to save.</param> 316public void SaveTo(Stream outStream)

Serialization\ColorTypeConverter.cs (1)

329Stream profileStream = colorContext.OpenProfileStream();

Serialization\ImageSourceTypeConverter.cs (5)

231using (Stream srcStream = MS.Internal.WpfWebRequestHelper.CreateRequestAndGetResponseStream(sourceUri)) 249Stream stream = new MemoryStream(); 327CopyImageStream( Stream sourceStream, Stream destinationStream ) 341ReEncodeImage(BitmapSource bitmapSource, BitmapEncoder encoder, Stream stream )

Serialization\Manager\NullPackagingPolicy.cs (2)

298Stream fontStream = null; 382Stream fontStream = new MemoryStream();

Serialization\Manager\XpsPackagingPolicy.cs (3)

35Stream stream, 51Stream 92Stream _stream;

Serialization\VisualTreeFlattener.cs (1)

146Stream bitmapStreamDest = new System.IO.FileStream(uri, FileMode.Create, FileAccess.ReadWrite, FileShare.None);

Serialization\XpsFontSubsetter.cs (3)

588Stream stream 611Stream destStream = _fontResourceStream.Stream; 612Stream sourceStream = null;

Serialization\XpsImageSerializationService.cs (1)

193Stream

SerializerFactory\XpsSerializerFactory.cs (1)

37public SerializerWriter CreateSerializerWriter(Stream stream)

SerializerFactory\XpsSerializerWriter.cs (1)

37public XpsSerializerWriter(Stream stream)

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

122public static async Task<BuildRequest> ReadAsync(Stream inStream, CancellationToken cancellationToken) 158public async Task WriteAsync(Stream outStream, CancellationToken cancellationToken = default(CancellationToken)) 280public async Task WriteAsync(Stream outStream, 318public static async Task<BuildResponse> ReadAsync(Stream stream, CancellationToken cancellationToken = default(CancellationToken)) 607Stream stream,

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

103private Stream? _loggingStream;

CustomDecompressionProvider.cs (2)

10public Stream GetDecompressionStream(Stream stream)

CustomCompressionProvider.cs (2)

14public Stream CreateStream(Stream outputStream)

Reader\PdbValidation.cs (9)

271Stream peStream, 272Stream pdbStream, 294Stream peStream, 295Stream pdbStream, 319Stream peStreamOriginal, 320Stream pdbStreamOriginal, 540public static unsafe byte[] GetSourceLinkData(Stream pdbStream) 563public static void ValidateDebugDirectory(Stream peStream, Stream portablePdbStreamOpt, string pdbPath, HashAlgorithmName hashAlgorithm, bool hasEmbeddedPdb, bool isDeterministic)

Reader\SymReaderFactory.cs (7)

38private static ISymUnmanagedReader5 CreateNativeSymReader(Stream pdbStream, object metadataImporter) 63private static ISymUnmanagedReader5 CreatePortableSymReader(Stream pdbStream, object metadataImporter) 78public static ISymUnmanagedReader5 CreateReader(Stream pdbStream, Stream peStreamOpt = null) 83public static ISymUnmanagedReader5 CreateReader(Stream pdbStream, PEReader peReaderOpt) 88public static ISymUnmanagedReader5 CreateReader(Stream pdbStream, MetadataReader metadataReaderOpt, IDisposable metadataMemoryOwnerOpt) 93public static ISymUnmanagedReader5 CreateReaderImpl(Stream pdbStream, object metadataImporter)

Reader\Token2SourceLineExporter.cs (7)

71internal void FillBuffer(Stream stream, int capacity) 78internal void Append(Stream stream, int count) 806internal PdbFileHeader(Stream reader, BitAccess bits) 837internal PdbReader(Stream reader, int pageSize) 859internal readonly Stream reader; 1138public static string TokenToSourceMap2Xml(Stream read, bool maskToken = false) 1193private static Dictionary<uint, PdbTokenLine> LoadTokenToSourceMapping(Stream read)

Writer\DelegatingSymUnmanagedWriter.cs (1)

89public override void WriteTo(Stream stream)

Writer\MockSymUnmanagedWriter.cs (1)

126public override void WriteTo(Stream stream)

Services\PerformanceTrackerServiceTests.cs (1)

246using var stream = assembly.GetManifestResourceStream(resourceName);

UnifiedSettings\UnifiedSettingsTests.cs (5)

132using var registrationFileStream = typeof(UnifiedSettingsTests).GetTypeInfo().Assembly.GetManifestResourceStream("Roslyn.VisualStudio.Next.UnitTests.csharpSettings.registration.json"); 146using var registrationFileStream = typeof(UnifiedSettingsTests).GetTypeInfo().Assembly.GetManifestResourceStream("Roslyn.VisualStudio.Next.UnitTests.csharpSettings.registration.json"); 234using var registrationFileStream = typeof(UnifiedSettingsTests).GetTypeInfo().Assembly.GetManifestResourceStream("Roslyn.VisualStudio.Next.UnitTests.visualBasicSettings.registration.json"); 248using var registrationFileStream = typeof(UnifiedSettingsTests).GetTypeInfo().Assembly.GetManifestResourceStream("Roslyn.VisualStudio.Next.UnitTests.visualBasicSettings.registration.json"); 281using var pkgDefFileStream = typeof(UnifiedSettingsTests).GetTypeInfo().Assembly.GetManifestResourceStream(pkgdefFileName);

src\OpenApi\test\Microsoft.AspNetCore.OpenApi.Tests\Shared\SharedTypes.cs (1)

50public required Stream Stream { get; set; }

ScenarioTestTypes.cs (1)

1201public void ReceiveStream(Stream stream)

ServiceInterfaces.cs (12)

73Stream GetStreamFromString(string data); 76string GetStringFromStream(Stream stream); 79Stream EchoStream(Stream stream); 82Task<Stream> EchoStreamAsync(Stream stream); 446void UploadStream(Stream stream); 449Stream DownloadStream(); 452Stream DownloadCustomizedStream(TimeSpan readThrottle, TimeSpan streamDuration); 479void UploadStream(Stream stream); 482Stream DownloadStream(); 511void ReceiveStream(Stream stream);

TestMockStream.cs (4)

21public TestMockStream(Stream innerStream) 26private Stream InnerStream { get; set; } 29public Func<Stream, int, CancellationToken, Task> CopyToAsyncFunc { get; set; } 48public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)

Tcp\StreamingTests.4.1.0.cs (14)

33Stream stream = null; 85var returnStream = serviceProxy.GetStreamFromString(testString); 115Stream stream = null; 127var returnStream = serviceProxy.EchoStream(stream); 157Stream stream = null; 169var returnStream = serviceProxy.EchoStream(stream); 267Stream stream = null; 279var returnStream = serviceProxy.EchoStreamAsync(stream).Result; 309Stream stream = null; 321var returnStream = serviceProxy.EchoStreamAsync(stream).Result; 351Stream stream = null; 363var returnStream = serviceProxy.EchoStreamAsync(stream).Result; 418private static string StreamToString(Stream stream) 424private static Stream StringToStream(string str)

GenerateFilteredReferenceAssembliesTask.cs (4)

525private static uint ReadUInt32(Stream stream) 528private static uint ReadUInt16(Stream stream) 531private static unsafe Guid ReadGuid(Stream stream) 550private static Guid CreateMvid(Stream stream)

ResponseCompressionTests.cs (1)

226using (var stream = await content.ReadAsStreamAsync())

ServerSentEvents\Helpers.cs (2)

86public static ValueTask WriteAsync(this Stream stream, ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default) 96static async ValueTask WriteAsyncUsingPooledBuffer(Stream stream, ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken)

ServerSentEvents\SseFormatter.cs (3)

30public static Task WriteAsync(IAsyncEnumerable<SseItem<string>> source, Stream destination, CancellationToken cancellationToken = default) 54public static Task WriteAsync<T>(IAsyncEnumerable<SseItem<T>> source, Stream destination, Action<SseItem<T>, IBufferWriter<byte>> itemFormatter, CancellationToken cancellationToken = default) 74private static async Task WriteAsyncCore<T>(IAsyncEnumerable<SseItem<T>> source, Stream destination, Action<SseItem<T>, IBufferWriter<byte>> itemFormatter, CancellationToken cancellationToken)

ServerSentEvents\SseParser.cs (3)

26/// This overload has behavior equivalent to calling <see cref="Create{T}(Stream, SseItemParser{T})"/> with a delegate 29public static SseParser<string> Create(Stream sseStream) => 38public static SseParser<T> Create<T>(Stream sseStream, SseItemParser<T> itemParser)

ServerSentEvents\SseParser_1.cs (2)

59private readonly Stream _stream; 104internal SseParser(Stream stream, SseItemParser<T> itemParser)

Program.cs (1)

52await using var uploadStream = file.OpenReadStream();

IStreamFormatter.cs (2)

8Task<T> ReadAsync(Stream stream); 9Task WriteAsync(T value, Stream stream);

Json\JSonStreamFormatter.cs (2)

12public async Task<T> ReadAsync(Stream stream) 19public Task WriteAsync(T value, Stream stream)

Pipe\PipeWeatherStreamFormatter.cs (2)

10public async Task<WeatherReport> ReadAsync(Stream stream) 50public async Task WriteAsync(WeatherReport report, Stream stream)

Protobuf\ProtobufWeatherStreamFormatter.cs (2)

10public Task<SocialWeather.WeatherReport> ReadAsync(Stream stream) 24public async Task WriteAsync(SocialWeather.WeatherReport weatherReport, Stream stream)

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

20private readonly Stream _stream; 23protected StreamBackedTestConnection(Stream stream, Encoding encoding = null) 29public Stream Stream => _stream;

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

20private readonly Stream _stream; 23protected StreamBackedTestConnection(Stream stream, Encoding encoding = null) 29public Stream Stream => _stream;

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

15public static async Task<int> FillBufferUntilEndAsync(this Stream stream, byte[] buffer, CancellationToken cancellationToken = default) 34public static async Task<int> FillEntireBufferAsync(this Stream stream, byte[] buffer, CancellationToken cancellationToken = default) 49public static async Task<byte[]> ReadAtLeastLengthAsync(this Stream stream, int length, int bufferLength = 1024, bool allowEmpty = false, CancellationToken cancellationToken = default) 76public static async Task<byte[]> ReadUntilEndAsync(this Stream stream, int bufferLength = 1024, CancellationToken cancellationToken = default)

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

389private static async Task WritePostRequestHeaders(Stream stream, int contentLength) 402private static async Task AssertStreamContains(Stream stream, string expectedSubstring)

src\Servers\Kestrel\test\FunctionalTests\RequestTests.cs (3)

873var readTask = request.Body.CopyToAsync(Stream.Null); 1059await context.Request.Body.CopyToAsync(Stream.Null); 1139private static async Task AssertStreamContains(Stream stream, string expectedSubstring)

src\Servers\Kestrel\test\FunctionalTests\ResponseTests.cs (4)

80var responseBody = await response.Content.ReadAsStreamAsync(); 1093private async Task AssertStreamAborted(Stream stream, int totalBytes) 1120private async Task AssertBytesReceivedAtTargetRate(Stream stream, int expectedBytes, int targetBytesPerSecond) 1143private async Task AssertStreamCompletedAtTargetRate(Stream stream, long expectedBytes, int targetBytesPerSecond)

ConsoleStresser.cs (1)

11var stdout = Console.OpenStandardOutput();

System\ComponentModel\Design\DesigntimeLicenseContext.cs (3)

80Stream? s = asm.GetManifestResourceStream(fileName + ".licenses"); 102Stream? s = resourceAssembly.GetManifestResourceStream(licResourceName); 141private static Stream? CaseInsensitiveManifestResourceStreamLookup(Assembly satellite, string name)

System\ComponentModel\Design\DesigntimeLicenseContextSerializer.cs (5)

32public static void Serialize(Stream o, string cryptoKey, DesigntimeLicenseContext context) 54private static void SerializeWithBinaryFormatter(Stream o, string cryptoKey, DesigntimeLicenseContext context) 66private readonly Stream _stream; 70public StreamWrapper(Stream stream) 163internal static void Deserialize(Stream o, string cryptoKey, RuntimeLicenseContext context)

System\ComponentModel\Design\Serialization\ComponentSerializationService.cs (1)

36public abstract SerializationStore LoadStore(Stream stream);

System\ComponentModel\Design\Serialization\SerializationStore.cs (1)

40public abstract void Save(Stream stream);

System\ComponentModel\LicFileLicenseProvider.cs (1)

87Stream licStream = new FileStream(licenseFile, FileMode.Open, FileAccess.Read, FileShare.Read);

src\libraries\Common\src\System\Security\IdentityHelper.cs (1)

66internal static string GetStrongHashSuitableForObjectName(Stream stream)

System\Configuration\AppSettingsSection.cs (1)

108using (Stream sourceFileStream = new FileStream(sourceFileFullPath, FileMode.Open, FileAccess.Read, FileShare.Read))

System\Configuration\BaseConfigurationRecord.cs (4)

556using (Stream stream = Host.OpenStreamForRead(ConfigStreamInfo.StreamName)) 702using (Stream stream = Host.OpenStreamForRead(ConfigStreamInfo.StreamName)) 1368using (Stream stream = Host.OpenStreamForRead(sectionXmlInfo.Filename)) 1494using (Stream stream = Host.OpenStreamForRead(configSourceStreamName))

System\Configuration\ClientConfigurationHost.cs (2)

278public override Stream OpenStreamForRead(string streamName) 310public override Stream OpenStreamForWrite(string streamName, string templateStreamName, ref object writeContext)

System\Configuration\ClientSettingsStore.cs (2)

290public override Stream OpenStreamForRead(string streamName) 302public override Stream OpenStreamForWrite(string streamName, string templateStreamName, ref object writeContext)

System\Configuration\ImplicitMachineConfigHost.cs (2)

61public override Stream OpenStreamForRead(string streamName) 63Stream stream = base.OpenStreamForRead(streamName);

System\Configuration\Internal\DelegatingConfigHost.cs (4)

83public virtual Stream OpenStreamForRead(string streamName) 88public virtual Stream OpenStreamForRead(string streamName, bool assertPermissions) 93public virtual Stream OpenStreamForWrite(string streamName, string templateStreamName, ref object writeContext) 98public virtual Stream OpenStreamForWrite(string streamName, string templateStreamName, ref object writeContext,

System\Configuration\Internal\IInternalConfigHost.cs (4)

48Stream OpenStreamForRead(string streamName); 50Stream OpenStreamForRead(string streamName, bool assertPermissions); 52Stream OpenStreamForWrite(string streamName, string templateStreamName, ref object writeContext); 54Stream OpenStreamForWrite(string streamName, string templateStreamName, ref object writeContext,

System\Configuration\Internal\InternalConfigHost.cs (7)

57Stream IInternalConfigHost.OpenStreamForRead(string streamName) 62Stream IInternalConfigHost.OpenStreamForRead(string streamName, bool assertPermissions) 67Stream IInternalConfigHost.OpenStreamForWrite(string streamName, string templateStreamName, 73Stream IInternalConfigHost.OpenStreamForWrite(string streamName, string templateStreamName, 222internal static Stream StaticOpenStreamForRead(string streamName) 234internal static Stream StaticOpenStreamForWrite(string streamName, string templateStreamName, ref object writeContext) 246Stream stream;

System\Configuration\MgmtConfigurationRecord.cs (7)

1016using (Stream streamRead = Host.OpenStreamForRead(ConfigStreamInfo.StreamName)) 1060using (Stream streamWrite = Host.OpenStreamForWrite(ConfigStreamInfo.StreamName, null, 2199using (Stream stream = new MemoryStream(buffer)) 2990using (Stream streamRead = Host.OpenStreamForRead(configSourceStreamName)) 3018Stream streamWrite = Host.OpenStreamForWrite(configSourceStreamName, templateStreamName, 3060using (Stream stream = new MemoryStream(buffer)) 3070using (Stream stream = new MemoryStream(buffer))

System\Configuration\UpdateConfigHost.cs (2)

76public override Stream OpenStreamForRead(string streamName) 84public override Stream OpenStreamForWrite(string streamName, string templateStreamName, ref object writeContext)

System\Configuration\XmlUtil.cs (3)

55private Stream _stream; 57internal XmlUtil(Stream stream, string name, bool readToFirstElement) : 61internal XmlUtil(Stream stream, string name, bool readToFirstElement, ConfigurationSchemaErrors schemaErrors)

System\Configuration\XmlUtilWriter.cs (1)

30private readonly Stream _baseStream; // stream under TextWriter when tracking position

System\Console.cs (8)

236private static TextWriter CreateOutputWriter(Stream outputStream) 238return outputStream == Stream.Null ? 617public static Stream OpenStandardInput() 624public static Stream OpenStandardInput(int bufferSize) 631public static Stream OpenStandardOutput() 636public static Stream OpenStandardOutput(int bufferSize) 643public static Stream OpenStandardError() 648public static Stream OpenStandardError(int bufferSize)

System\ConsolePal.Unix.cs (5)

46public static Stream OpenStandardInput() 52public static Stream OpenStandardOutput() 57public static Stream OpenStandardError() 103Stream inputStream = OpenStandardInput(); 105inputStream == Stream.Null ?

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

212public virtual Stream GetStream(int ordinal)

System\Data\DataReaderExtensions.cs (1)

157public static Stream GetStream(this DbDataReader reader, string name)

System\Data\DataSet.cs (14)

1618public void InferXmlSchema(Stream? stream, string[]? nsArray) 1867/// Reads the XML schema from the specified <see cref='System.IO.Stream'/> into the 1872public void ReadXmlSchema(Stream? stream) 1916/// <summary>Writes the <see cref='DataSet'/> structure as an XML schema to using the specified <see cref='Stream'/> object.</summary> 1917/// <param name="stream">A <see cref='Stream'/> object used to write to a file.</param> 1920public void WriteXmlSchema(Stream? stream) => WriteXmlSchema(stream, SchemaFormat.Public, null); 1922/// <summary>Writes the <see cref='DataSet'/> structure as an XML schema to using the specified <see cref='Stream'/> object.</summary> 1923/// <param name="stream">A <see cref='Stream'/> object used to write to a file.</param> 1927public void WriteXmlSchema(Stream? stream, Converter<Type, string> multipleTargetConverter) 2004private void WriteXmlSchema(Stream? stream, SchemaFormat schemaFormat, Converter<Type, string>? multipleTargetConverter) 2345public XmlReadMode ReadXml(Stream? stream) 2838public XmlReadMode ReadXml(Stream? stream, XmlReadMode mode) 2896public void WriteXml(Stream? stream) => WriteXml(stream, XmlWriteMode.IgnoreSchema); 2915public void WriteXml(Stream? stream, XmlWriteMode mode)

System\Data\DataTable.cs (8)

5316public void WriteXml(Stream? stream) => WriteXml(stream, XmlWriteMode.IgnoreSchema, false); 5320public void WriteXml(Stream? stream, bool writeHierarchy) => WriteXml(stream, XmlWriteMode.IgnoreSchema, writeHierarchy); 5348public void WriteXml(Stream? stream, XmlWriteMode mode) => WriteXml(stream, mode, false); 5352public void WriteXml(Stream? stream, XmlWriteMode mode, bool writeHierarchy) 5488public void WriteXmlSchema(Stream? stream) => WriteXmlSchema(stream, false); 5492public void WriteXmlSchema(Stream? stream, bool writeHierarchy) 5642public XmlReadMode ReadXml(Stream? stream) 6432public void ReadXmlSchema(Stream? stream)

System\Data\SQLTypes\SQLBytes.cs (3)

47internal Stream? _stream; 89public SqlBytes(Stream? s) 222public Stream Stream

System\Data\SQLTypes\SqlXml.cs (8)

19private static readonly Func<Stream, XmlReaderSettings, XmlParserContext?, XmlReader> s_sqlReaderDelegate = CreateSqlReaderDelegate(); 26private Stream? _stream; 56public SqlXml(Stream? value) 96internal static XmlReader CreateSqlXmlReader(Stream stream, bool closeInput = false, bool throwTargetInvocationExceptions = false) 118private static Func<Stream, XmlReaderSettings, XmlParserContext?, XmlReader> CreateSqlReaderDelegate() 122return CreateSqlReaderMethodInfo.CreateDelegate<Func<Stream, XmlReaderSettings, XmlParserContext?, XmlReader>>(); 272private readonly Stream _stream; 280internal SqlXmlStreamWrapper(Stream stream)

System\Data\xmlsaver.cs (1)

3139internal Stream? BaseStream

System\Xml\XmlDataDocument.cs (1)

1150public override void Load(Stream inStream)

src\libraries\Common\src\System\Data\ProviderBase\DbMetaDataFactory.cs (1)

34public DbMetaDataFactory(Stream xmlStream, string serverVersion, string normalizedServerVersion)

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

66Stream? XMLStream = System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceStream("System.Data.Odbc.OdbcMetaData.xml");

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

34internal OdbcMetaDataFactory(Stream XMLStream,

System\Diagnostics\AsyncStreamReader.cs (2)

27private readonly Stream _stream; 48internal AsyncStreamReader(Stream stream, Action<string?> callback, Encoding encoding)

System\Diagnostics\Process.cs (2)

1610Stream s = _standardOutput.BaseStream; 1650Stream s = _standardError.BaseStream;

System\Diagnostics\StackTraceSymbols.cs (2)

176Stream? peStream = TryOpenFile(assemblyPath); 223private static Stream? TryOpenFile(string path)

System\Diagnostics\DelimitedListTraceListener.cs (2)

20public DelimitedListTraceListener(Stream stream) : base(stream) 24public DelimitedListTraceListener(Stream stream, string? name) : base(stream, name)

System\Diagnostics\TextWriterTraceListener.cs (3)

11/// a <see cref='System.IO.TextWriter'/> or to a <see cref='System.IO.Stream'/>, 32public TextWriterTraceListener(Stream stream) 41public TextWriterTraceListener(Stream stream, string? name)

System\Diagnostics\XmlWriterTraceListener.cs (2)

24public XmlWriterTraceListener(Stream stream) 29public XmlWriterTraceListener(Stream stream, string? name)

Special\NotSupported.cs (24)

mono\System.Imaging\MetafileTest.cs (1)

247private void Metafile_StreamEmfType(Stream stream, EmfType type)

System\Drawing\BitmapTests.cs (11)

120using Stream stream = File.OpenRead(Helpers.GetTestBitmapPath(filename)); 134using Stream stream = File.OpenRead(Helpers.GetTestBitmapPath(filename)); 146AssertExtensions.Throws<ArgumentNullException, ArgumentException>("stream", null, () => new Bitmap((Stream)null)); 147AssertExtensions.Throws<ArgumentNullException, ArgumentException>("stream", null, () => new Bitmap((Stream)null, false)); 740using Stream wmfStream = File.OpenRead(Helpers.GetTestBitmapPath("gdiwmfboundariesbug.wmf")); 744using Stream expectedPngStream = File.OpenRead(Helpers.GetTestBitmapPath("gdiwmfboundariesbug-output.png")); 747using Stream outputPngStream = File.OpenRead(output); 1587using Stream backingStream = new MemoryStream(); 1588using Stream restrictiveStream = new TestStream(backingStream, canRead, canSeek); 1693private readonly Stream _stream; 1697public TestStream(Stream stream, bool canRead = true, bool canSeek = true)

System\Drawing\IconTests.cs (3)

145AssertExtensions.Throws<ArgumentNullException, ArgumentException>("stream", null, () => new Icon((Stream)null)); 146AssertExtensions.Throws<ArgumentNullException, ArgumentException>("stream", null, () => new Icon((Stream)null, 32, 32)); 147AssertExtensions.Throws<ArgumentNullException, ArgumentException>("stream", null, () => new Icon((Stream)null, new Size(32, 32)));

System\Drawing\Imaging\MetafileTests.cs (6)

101AssertExtensions.Throws<ArgumentNullException, ArgumentException>("stream", null, () => new Metafile((Stream)null)); 827Assert.Throws<ArgumentNullException>(() => new Metafile((Stream)null, referenceHdc, _rectangleF)); 828Assert.Throws<ArgumentNullException>(() => new Metafile((Stream)null, referenceHdc, _rectangleF, MetafileFrameUnit.GdiCompatible)); 830new Metafile((Stream)null, referenceHdc, _rectangleF, MetafileFrameUnit.GdiCompatible, EmfType.EmfOnly)); 832new Metafile((Stream)null, referenceHdc, _rectangleF, MetafileFrameUnit.GdiCompatible, EmfType.EmfOnly, "description")); 875Assert.Throws<ArgumentNullException>(() => Metafile.GetMetafileHeader((Stream)null));

System\Formats\Nrbf\NrbfDecoder.cs (6)

52public static bool StartsWithPayloadHeader(Stream stream) 116public static SerializationRecord Decode(Stream payload, PayloadOptions? options = default, bool leaveOpen = false) 129/// <inheritdoc cref="Decode(Stream, PayloadOptions?, bool)"/> 130public static SerializationRecord Decode(Stream payload, out IReadOnlyDictionary<SerializationRecordId, SerializationRecord> recordMap, PayloadOptions? options = default, bool leaveOpen = false) 156/// <inheritdoc cref="Decode(Stream, PayloadOptions?, bool)"/> 157public static ClassRecord DecodeClassRecord(Stream payload, PayloadOptions? options = default, bool leaveOpen = false)

System\Formats\Tar\SeekableSubReadStream.cs (1)

16public SeekableSubReadStream(Stream superStream, long startPosition, long maxLength)

System\Formats\Tar\SubReadStream.cs (2)

21protected readonly Stream _superStream; 24public SubReadStream(Stream superStream, long startPosition, long maxLength)

System\Formats\Tar\TarEntry.cs (2)

188/// <para>Hard links can only be extracted when using <see cref="TarFile.ExtractToDirectory(Stream, string, bool)"/> or <see cref="TarFile.ExtractToDirectory(string, string, bool)"/>.</para></remarks> 253public Stream? DataStream

System\Formats\Tar\TarFile.cs (10)

31public static void CreateFromDirectory(string sourceDirectoryName, Stream destination, bool includeBaseDirectory) 66public static Task CreateFromDirectoryAsync(string sourceDirectoryName, Stream destination, bool includeBaseDirectory, CancellationToken cancellationToken = default) 171public static void ExtractToDirectory(Stream source, string destinationDirectoryName, bool overwriteFiles) 212public static Task ExtractToDirectoryAsync(Stream source, string destinationDirectoryName, bool overwriteFiles, CancellationToken cancellationToken = default) 326private static void CreateFromDirectoryInternal(string sourceDirectoryName, Stream destination, bool includeBaseDirectory, bool leaveOpen) 379private static async Task CreateFromDirectoryInternalAsync(string sourceDirectoryName, Stream destination, bool includeBaseDirectory, bool leaveOpen, CancellationToken cancellationToken) 454private static void ExtractToDirectoryInternal(Stream source, string destinationDirectoryFullPath, bool overwriteFiles, bool leaveOpen) 497private static async Task ExtractToDirectoryInternalAsync(Stream source, string destinationDirectoryFullPath, bool overwriteFiles, bool leaveOpen, CancellationToken cancellationToken) 521private static void VerifyCreateFromDirectoryArguments(string sourceDirectoryName, Stream destination) 530private static void VerifyExtractToDirectoryArguments(Stream source, string destinationDirectoryPath)

System\Formats\Tar\TarHeader.cs (2)

42internal Stream? _dataStream; 157private static void SetDataOffset(TarHeader header, Stream archiveStream) =>

System\Formats\Tar\TarHeader.Read.cs (13)

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

System\Formats\Tar\TarHelpers.cs (8)

52internal static void AdvanceStream(Stream archiveStream, long bytesToDiscard) 72internal static async ValueTask AdvanceStreamAsync(Stream archiveStream, long bytesToDiscard, CancellationToken cancellationToken) 94internal static void CopyBytes(Stream origin, Stream destination, long bytesToCopy) 108internal static async ValueTask CopyBytesAsync(Stream origin, Stream destination, long bytesToCopy, CancellationToken cancellationToken) 312internal static int SkipBlockAlignmentPadding(Stream archiveStream, long size) 322internal static async ValueTask<int> SkipBlockAlignmentPaddingAsync(Stream archiveStream, long size, CancellationToken cancellationToken)

System\Formats\Tar\TarReader.cs (6)

21private List<Stream>? _dataStreamsToDispose; 24internal Stream _archiveStream; 33public TarReader(Stream archiveStream, bool leaveOpen = false) 64foreach (Stream s in _dataStreamsToDispose) 89foreach (Stream s in _dataStreamsToDispose) 624_dataStreamsToDispose ??= new List<Stream>();

System\Formats\Tar\TarWriter.cs (4)

20private readonly Stream _archiveStream; 30public TarWriter(Stream archiveStream) 42public TarWriter(Stream archiveStream, bool leaveOpen = false) 59public TarWriter(Stream archiveStream, TarEntryFormat format = TarEntryFormat.Pax, bool leaveOpen = false)

System.IO.cs (1)

7[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.IO.Stream))]

System\IO\Compression\DeflateManaged\DeflateManagedStream.cs (2)

16private Stream? _stream; 23internal DeflateManagedStream(Stream stream, ZipArchiveEntry.CompressionMethodValues method, long uncompressedSize = -1)

System\IO\Compression\DeflateZLib\DeflateStream.cs (18)

18private Stream _stream; 27internal DeflateStream(Stream stream, CompressionMode mode, long uncompressedSize) : this(stream, mode, leaveOpen: false, ZLibNative.Deflate_DefaultWindowBits, uncompressedSize) 31public DeflateStream(Stream stream, CompressionMode mode) : this(stream, mode, leaveOpen: false) 35public DeflateStream(Stream stream, CompressionMode mode, bool leaveOpen) : this(stream, mode, leaveOpen, ZLibNative.Deflate_DefaultWindowBits) 40public DeflateStream(Stream stream, CompressionLevel compressionLevel) : this(stream, compressionLevel, leaveOpen: false) 45public DeflateStream(Stream stream, CompressionLevel compressionLevel, bool leaveOpen) : this(stream, compressionLevel, leaveOpen, ZLibNative.Deflate_DefaultWindowBits) 56public DeflateStream(Stream stream, ZLibCompressionOptions compressionOptions, bool leaveOpen = false) : this(stream, compressionOptions, leaveOpen, ZLibNative.Deflate_DefaultWindowBits) 60internal DeflateStream(Stream stream, ZLibCompressionOptions compressionOptions, bool leaveOpen, int windowBits) 72internal DeflateStream(Stream stream, CompressionMode mode, bool leaveOpen, int windowBits, long uncompressedSize = -1) 100internal DeflateStream(Stream stream, CompressionLevel compressionLevel, bool leaveOpen, int windowBits) 111internal void InitializeDeflater(Stream stream, ZLibNative.CompressionLevel compressionLevel, CompressionStrategy strategy, bool leaveOpen, int windowBits) 156public Stream BaseStream => _stream; 766Stream stream = _stream; 879public override void CopyTo(Stream destination, int bufferSize) 889public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken) 910private readonly Stream _destination; 914public CopyToStream(DeflateStream deflateStream, Stream destination, int bufferSize) : 919public CopyToStream(DeflateStream deflateStream, Stream destination, int bufferSize, CancellationToken cancellationToken)

System\IO\Compression\GZipStream.cs (8)

15public GZipStream(Stream stream, CompressionMode mode) : this(stream, mode, leaveOpen: false) 19public GZipStream(Stream stream, CompressionMode mode, bool leaveOpen) 25public GZipStream(Stream stream, CompressionLevel compressionLevel) : this(stream, compressionLevel, leaveOpen: false) 30public GZipStream(Stream stream, CompressionLevel compressionLevel, bool leaveOpen) 42public GZipStream(Stream stream, ZLibCompressionOptions compressionOptions, bool leaveOpen = false) 158public override void CopyTo(Stream destination, int bufferSize) 197public Stream BaseStream => _deflateStream?.BaseStream!; 249public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)

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

11private readonly Stream _stream; 18public PositionPreservingWriteOnlyStreamWrapper(Stream stream)

System\IO\Compression\ZipArchive.cs (9)

18private readonly Stream _archiveStream; 30private readonly Stream? _backingStream; 46public ZipArchive(Stream stream) : this(stream, ZipArchiveMode.Read, leaveOpen: false, entryNameEncoding: null) { } 57public ZipArchive(Stream stream, ZipArchiveMode mode) : this(stream, mode, leaveOpen: false, entryNameEncoding: null) { } 69public ZipArchive(Stream stream, ZipArchiveMode mode, bool leaveOpen) : this(stream, mode, leaveOpen, entryNameEncoding: null) { } 121public ZipArchive(Stream stream, ZipArchiveMode mode, bool leaveOpen, Encoding? entryNameEncoding) 126Stream? extraTempStream = null; 216/// The comment encoding is determined by the <c>entryNameEncoding</c> parameter of the <see cref="ZipArchive(Stream,ZipArchiveMode,bool,Encoding?)"/> constructor. 357internal Stream ArchiveStream => _archiveStream;

System\IO\Compression\ZipArchiveEntry.cs (13)

40private Stream? _outstandingWriteStream; 203///The comment encoding is determined by the <c>entryNameEncoding</c> parameter of the <see cref="ZipArchive(Stream,ZipArchiveMode,bool,Encoding?)"/> constructor. 343public Stream Open() 419using (Stream decompressor = OpenInReadMode(false)) 668private CheckSumAndSizeWriteStream GetDataCompressor(Stream backingStream, bool leaveBackingStreamOpen, EventHandler? onClose) 679Stream compressorStream; 700(long initialPosition, long currentPosition, uint checkSum, Stream backing, ZipArchiveEntry thisRef, EventHandler? closeHandler) => 711private Stream GetDataDecompressor(Stream compressedStreamToRead) 713Stream? uncompressedStream; 735private Stream OpenInReadMode(bool checkOpenable) 740Stream compressedStream = new SubReadStream(_archive.ArchiveStream, OffsetOfCompressedData, _compressedSize); 1041using (Stream entryWriter = new DirectToArchiveWriterStream(

System\IO\Compression\ZipBlocks.cs (12)

System\IO\Compression\ZipCustomStreams.cs (12)

13private readonly Stream _baseStream; 23internal WrappedStream(Stream baseStream, bool closeBaseStream) 26private WrappedStream(Stream baseStream, bool closeBaseStream, ZipArchiveEntry? entry, Action<ZipArchiveEntry?>? onClosed) 35internal WrappedStream(Stream baseStream, ZipArchiveEntry entry, Action<ZipArchiveEntry?>? onClosed) 226private readonly Stream _superStream; 230public SubReadStream(Stream superStream, long startPosition, long maxLength) 405private readonly Stream _baseStream; 406private readonly Stream _baseBaseStream; 422private readonly Action<long, long, uint, Stream, ZipArchiveEntry, EventHandler?> _saveCrcAndSizes; 431public CheckSumAndSizeWriteStream(Stream baseStream, Stream baseBaseStream, bool leaveOpenOnClose, 433Action<long, long, uint, Stream, ZipArchiveEntry, EventHandler?> saveCrcAndSizes)

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

38internal static int ReadBytes(Stream stream, Span<byte> buffer, int bytesToRead) 106internal static bool SeekBackwardsToSignature(Stream stream, ReadOnlySpan<byte> signatureToFind, int maxBytesToRead) 173private static int SeekBackwardsAndRead(Stream stream, Span<byte> buffer, int overlap)

System\IO\Compression\ZLibStream.cs (10)

19public ZLibStream(Stream stream, CompressionMode mode) : this(stream, mode, leaveOpen: false) 27public ZLibStream(Stream stream, CompressionMode mode, bool leaveOpen) 35public ZLibStream(Stream stream, CompressionLevel compressionLevel) : this(stream, compressionLevel, leaveOpen: false) 43public ZLibStream(Stream stream, CompressionLevel compressionLevel, bool leaveOpen) 55public ZLibStream(Stream stream, ZLibCompressionOptions compressionOptions, bool leaveOpen = false) 239public override void CopyTo(Stream destination, int bufferSize) 250public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken) 256/// <summary>Releases all resources used by the <see cref="Stream"/>.</summary> 274/// <summary>Asynchronously releases all resources used by the <see cref="Stream"/>.</summary> 289public Stream BaseStream => _deflateStream?.BaseStream!;

System\IO\Compression\BrotliStream.cs (4)

15private Stream _stream; 23public BrotliStream(Stream stream, CompressionMode mode) : this(stream, mode, leaveOpen: false) { } 29public BrotliStream(Stream stream, CompressionMode mode, bool leaveOpen) 141public Stream BaseStream => _stream;

System\IO\Compression\dec\BrotliStream.Decompress.cs (2)

86/// <summary>Begins an asynchronous read operation. (Consider using the <see cref="System.IO.Stream.ReadAsync(byte[],int,int)" /> method instead.)</summary> 101/// <summary>Waits for the pending asynchronous read to complete. (Consider using the <see cref="System.IO.Stream.ReadAsync(byte[],int,int)" /> method instead.)</summary>

System\IO\Compression\enc\BrotliStream.Compress.cs (5)

20public BrotliStream(Stream stream, CompressionLevel compressionLevel) : this(stream, compressionLevel, leaveOpen: false) { } 27public BrotliStream(Stream stream, CompressionLevel compressionLevel, bool leaveOpen) : this(stream, CompressionMode.Compress, leaveOpen) 39public BrotliStream(Stream stream, BrotliCompressionOptions compressionOptions, bool leaveOpen = false) : this(stream, CompressionMode.Compress, leaveOpen) 100/// <summary>Begins an asynchronous write operation. (Consider using the <see cref="System.IO.Stream.WriteAsync(byte[],int,int)" /> method instead.)</summary> 115/// <summary>Handles the end of an asynchronous write operation. (Consider using the <see cref="System.IO.Stream.WriteAsync(byte[],int,int)" /> method instead.)</summary>

System\IO\Compression\ZipFile.Create.cs (5)

360/// If you want to include the base directory or specify a compression level, call the <see cref="CreateFromDirectory(string, Stream, CompressionLevel, bool)"/> method overload. 374public static void CreateFromDirectory(string sourceDirectoryName, Stream destination) => 401public static void CreateFromDirectory(string sourceDirectoryName, Stream destination, CompressionLevel compressionLevel, bool includeBaseDirectory) => 429public static void CreateFromDirectory(string sourceDirectoryName, Stream destination, 449private static void DoCreateFromDirectory(string sourceDirectoryName, Stream destination,

System\IO\Compression\ZipFile.Extract.cs (4)

216public static void ExtractToDirectory(Stream source, string destinationDirectoryName) => 245public static void ExtractToDirectory(Stream source, string destinationDirectoryName, bool overwriteFiles) => 282public static void ExtractToDirectory(Stream source, string destinationDirectoryName, Encoding? entryNameEncoding) => 320public static void ExtractToDirectory(Stream source, string destinationDirectoryName, Encoding? entryNameEncoding, bool overwriteFiles)

System\IO\Compression\ZipFileExtensions.ZipArchive.Create.cs (1)

109using (Stream es = entry.Open())

System\IO\Compression\ZipFileExtensions.ZipArchiveEntry.Extract.cs (1)

93using (Stream es = source.Open())

System\IO\Hashing\NonCryptographicHashAlgorithm.cs (4)

103/// <seealso cref="AppendAsync(Stream, CancellationToken)"/> 104public void Append(Stream stream) 130public Task AppendAsync(Stream stream, CancellationToken cancellationToken = default) 320private sealed class CopyToDestinationStream(NonCryptographicHashAlgorithm hash) : Stream

src\libraries\Common\src\System\Security\IdentityHelper.cs (1)

66internal static string GetStrongHashSuitableForObjectName(Stream stream)

System\IO\Packaging\IgnoreFlushAndCloseStream.cs (2)

20internal IgnoreFlushAndCloseStream(Stream stream) 184private Stream _stream;

System\IO\Packaging\InterleavedZipPackagePartStream.cs (4)

99Stream pieceStream = _dir.GetStream(pieceNumber); 266Stream lastPieceStream = _dir.GetStream(lastPieceNumber); 317Stream pieceStream = _dir.GetStream(pieceNumber); 543private static void SeekUnderlyingPieceStream(Stream pieceStream, long byteCount)

System\IO\Packaging\InterleavedZipPackagePartStream.PieceDirectory.cs (7)

59private readonly Stream _temporaryMemoryStream = new MemoryStream(0); 76internal PieceStreamInfo(Stream stream, long pieceStart) 92internal Stream Stream { get; set; } 203internal Stream GetStream(int pieceNumber) 215internal Stream ResetStream(int pieceNumber) 361Stream pieceStream = _zipStreamManager.Open(_sortedPieceInfoList[pieceNumber].ZipArchiveEntry, 442Stream pieceStream = _zipStreamManager.Open(newLastPieceDescriptor.ZipArchiveEntry, _fileAccess);

System\IO\Packaging\InternalRelationshipCollection.cs (2)

227using (Stream s = part.GetStream(FileMode.Open, FileAccess.Read)) 458using (Stream partStream = part.GetStream())

System\IO\Packaging\Package.cs (3)

145public static Package Open(Stream stream) 162public static Package Open(Stream stream, FileMode packageMode) 919public static Package Open(Stream stream, FileMode packageMode, FileAccess packageAccess)

System\IO\Packaging\PackagePart.cs (10)

271public Stream GetStream() 293public Stream GetStream(FileMode mode) 317public Stream GetStream(FileMode mode, FileAccess access) 327Stream? s = GetStreamCore(mode, access); 340_requestedStreams ??= new List<Stream>(); //Default capacity is 4 360protected abstract Stream? GetStreamCore(FileMode mode, FileAccess access); 592foreach (Stream s in _requestedStreams) 621foreach (Stream s in _requestedStreams) 790private static bool IsStreamClosed(Stream s) 802private List<Stream>? _requestedStreams;

System\IO\Packaging\PartBasedPackageProperties.cs (4)

316Stream? zipStream = null; 481using (Stream stream = part.GetStream(FileMode.Open, FileAccess.Read)) 678private void EnsureXmlWriter(ref Stream? zipStream) 686Stream writerStream = new IgnoreFlushAndCloseStream(zipStream);

System\IO\Packaging\ZipPackage.cs (5)

352internal ZipPackage(Stream s, FileMode packageFileMode, FileAccess packageFileAccess) 706private Stream _containerStream; // stream we are opened in if Open(Stream) was called 908using (Stream s = _zipStreamManager.Open(_contentTypeZipArchiveEntry, FileAccess.ReadWrite)) 957Stream? s = OpenContentTypeStream(zipFiles); 1045private Stream? OpenContentTypeStream(System.Collections.ObjectModel.ReadOnlyCollection<ZipArchiveEntry> zipFiles)

System\IO\Packaging\ZipPackagePart.cs (3)

24protected override Stream? GetStreamCore(FileMode streamFileMode, FileAccess streamFileAccess) 35using (var tempStream = _zipStreamManager.Open(_zipArchiveEntry, streamFileAccess)) 41var stream = _zipStreamManager.Open(_zipArchiveEntry, streamFileAccess);

System\IO\Packaging\ZipStreamManager.cs (2)

25public Stream Open(ZipArchiveEntry zipArchiveEntry, FileAccess streamFileAccess) 84Stream ns = zipArchiveEntry.Open();

System\IO\Packaging\ZipWrappingStream.cs (2)

15private readonly Stream _baseStream; 22public ZipWrappingStream(ZipArchiveEntry zipArchiveEntry, Stream stream, FileMode packageFileMode, FileAccess packageFileAccess, bool canRead, bool canWrite)

src\libraries\Common\src\System\IO\StreamHelpers.CopyValidation.cs (2)

10public static void ValidateCopyToArgs(Stream source, Stream destination, int bufferSize)

System\IO\Pipelines\PipeReader.cs (7)

System\IO\Pipelines\PipeReaderStream.cs (1)

151public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)

System\IO\Pipelines\PipeWriter.cs (7)

System\IO\Pipelines\StreamPipeExtensions.cs (3)

9/// <summary>Provides extension methods for <see cref="System.IO.Stream" /> that support read and write operations directly into pipes.</summary> 12/// <summary>Asynchronously reads the bytes from the <see cref="System.IO.Stream" /> and writes them to the specified <see cref="System.IO.Pipelines.PipeWriter" />, using a cancellation token.</summary> 17public static Task CopyToAsync(this Stream source, PipeWriter destination, CancellationToken cancellationToken = default)

System\IO\Pipelines\StreamPipeReader.cs (3)

39public StreamPipeReader(Stream readingStream, StreamPipeReaderOptions options) 66public Stream InnerStream { get; } 382public override async Task CopyToAsync(Stream destination, CancellationToken cancellationToken = default)

System\IO\Pipelines\StreamPipeWriter.cs (2)

46public StreamPipeWriter(Stream writingStream, StreamPipeWriterOptions options) 68public Stream InnerStream { get; }

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

141public Stream BaseStream

src\libraries\Common\src\System\IO\ReadOnlyMemoryStream.cs (3)

9/// <summary>Provides a <see cref="Stream"/> for the contents of a <see cref="ReadOnlyMemory{Byte}"/>.</summary> 155public override void CopyTo(Stream destination, int bufferSize) 166public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)

System\BinaryData.cs (6)

228public static BinaryData FromStream(Stream stream) => FromStream(stream, mediaType: null); 239public static BinaryData FromStream(Stream stream, string? mediaType) 256public static Task<BinaryData> FromStreamAsync(Stream stream, CancellationToken cancellationToken = default) 269public static Task<BinaryData> FromStreamAsync(Stream stream, string? mediaType, 280private static async Task<BinaryData> FromStreamAsync(Stream stream, bool useAsync, 453public Stream ToStream() => new ReadOnlyMemoryStream(_bytes);

src\libraries\Common\src\System\IO\DelegatingStream.cs (4)

14private readonly Stream _innerStream; 63protected DelegatingStream(Stream innerStream) 125public override void CopyTo(Stream destination, int bufferSize) 130public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)

src\libraries\Common\src\System\IO\ReadOnlyMemoryStream.cs (3)

9/// <summary>Provides a <see cref="Stream"/> for the contents of a <see cref="ReadOnlyMemory{Byte}"/>.</summary> 155public override void CopyTo(Stream destination, int bufferSize) 166public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)

System\Net\Http\ByteArrayContent.cs (8)

40protected override void SerializeToStream(Stream stream, TransportContext? context, CancellationToken cancellationToken) => 43protected override Task SerializeToStreamAsync(Stream stream, TransportContext? context) => 46protected override Task SerializeToStreamAsync(Stream stream, TransportContext? context, CancellationToken cancellationToken) => 52private protected Task SerializeToStreamAsyncCore(Stream stream, CancellationToken cancellationToken) => 61protected override Stream CreateContentReadStream(CancellationToken cancellationToken) => 64protected override Task<Stream> CreateContentReadStreamAsync() => 65Task.FromResult<Stream>(CreateMemoryStreamForByteArray()); 67internal override Stream? TryCreateContentReadStream() =>

System\Net\Http\EmptyContent.cs (9)

19protected override void SerializeToStream(Stream stream, TransportContext? context, CancellationToken cancellationToken) 22protected override Task SerializeToStreamAsync(Stream stream, TransportContext? context) => 25protected override Task SerializeToStreamAsync(Stream stream, TransportContext? context, CancellationToken cancellationToken) => 29protected override Stream CreateContentReadStream(CancellationToken cancellationToken) => 32protected override Task<Stream> CreateContentReadStreamAsync() => 33Task.FromResult<Stream>(EmptyReadStream.Instance); 35protected override Task<Stream> CreateContentReadStreamAsync(CancellationToken cancellationToken) => 36cancellationToken.IsCancellationRequested ? Task.FromCanceled<Stream>(cancellationToken) : 39internal override Stream? TryCreateContentReadStream() => EmptyReadStream.Instance;

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

28public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)

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

89protected override Task SerializeToStreamAsync(Stream stream, TransportContext? context, CancellationToken cancellationToken) => 95internal override Stream? TryCreateContentReadStream() =>

System\Net\Http\HttpClient.cs (7)

207using Stream responseStream = c.TryReadAsStream() ?? await c.ReadAsStreamAsync(cts.Token).ConfigureAwait(false); 283using Stream responseStream = c.TryReadAsStream() ?? await c.ReadAsStreamAsync(cts.Token).ConfigureAwait(false); 306public Task<Stream> GetStreamAsync([StringSyntax(StringSyntaxAttribute.Uri)] string? requestUri) => 309public Task<Stream> GetStreamAsync([StringSyntax(StringSyntaxAttribute.Uri)] string? requestUri, CancellationToken cancellationToken) => 312public Task<Stream> GetStreamAsync(Uri? requestUri) => 315public Task<Stream> GetStreamAsync(Uri? requestUri, CancellationToken cancellationToken) 325private async Task<Stream> GetStreamAsyncCore(HttpRequestMessage request, CancellationToken cancellationToken)

System\Net\Http\HttpContent.cs (37)

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

15/// When calling <see cref="Stream"/> methods on the stream returned by <see cref="HttpContent.ReadAsStream()"/> or

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

156protected override void SerializeToStream(Stream stream, TransportContext? context, CancellationToken cancellationToken) 191protected override Task SerializeToStreamAsync(Stream stream, TransportContext? context) => 194protected override Task SerializeToStreamAsync(Stream stream, TransportContext? context, CancellationToken cancellationToken) => 200private protected async Task SerializeToStreamAsyncCore(Stream stream, TransportContext? context, CancellationToken cancellationToken) 233protected override Stream CreateContentReadStream(CancellationToken cancellationToken) 235ValueTask<Stream> task = CreateContentReadStreamAsyncCore(async: false, cancellationToken); 240protected override Task<Stream> CreateContentReadStreamAsync() => 243protected override Task<Stream> CreateContentReadStreamAsync(CancellationToken cancellationToken) => 249private async ValueTask<Stream> CreateContentReadStreamAsyncCore(bool async, CancellationToken cancellationToken) 253var streams = new Stream[2 + (_nestedContent.Count * 2)]; 267Stream readStream; 306private void SerializeHeadersToStream(Stream stream, HttpContent content, bool writeDivider) 337private static ValueTask EncodeStringToStreamAsync(Stream stream, string input, CancellationToken cancellationToken) 413private readonly Stream[] _streams; 417private Stream? _current; 420internal ContentReadStream(Stream[] streams) 424foreach (Stream stream in streams) 434foreach (Stream s in _streams) 443foreach (Stream s in _streams) 575Stream curStream = _streams[i]; 639private static void WriteToStream(Stream stream, string content) => 642private static void WriteToStream(Stream stream, string content, Encoding encoding)

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

66protected override Task SerializeToStreamAsync(Stream stream, TransportContext? context, CancellationToken cancellationToken) =>

System\Net\Http\ReadOnlyMemoryContent.cs (7)

17protected override void SerializeToStream(Stream stream, TransportContext? context, CancellationToken cancellationToken) 22protected override Task SerializeToStreamAsync(Stream stream, TransportContext? context) => 25protected override Task SerializeToStreamAsync(Stream stream, TransportContext? context, CancellationToken cancellationToken) => 34protected override Stream CreateContentReadStream(CancellationToken cancellationToken) => 37protected override Task<Stream> CreateContentReadStreamAsync() => 38Task.FromResult<Stream>(new ReadOnlyMemoryStream(_content)); 40internal override Stream TryCreateContentReadStream() =>

System\Net\Http\SocketsHttpHandler\ChunkedEncodingReadStream.cs (2)

244public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken) 254private async Task CopyToAsyncCore(Stream destination, CancellationToken cancellationToken)

System\Net\Http\SocketsHttpHandler\ConnectHelper.cs (2)

58public static async ValueTask<SslStream> EstablishSslConnectionAsync(SslClientAuthenticationOptions sslOptions, HttpRequestMessage request, bool async, Stream stream, CancellationToken cancellationToken) 72using (cancellationToken.UnsafeRegister(static s => ((Stream)s!).Dispose(), stream))

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

90public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)

System\Net\Http\SocketsHttpHandler\ConnectionPool\HttpConnectionPool.cs (14)

568private async ValueTask<(Stream, TransportContext?, Activity?, IPEndPoint?)> ConnectAsync(HttpRequestMessage request, bool async, CancellationToken cancellationToken) 570Stream? stream = null; 607if (stream is HttpContentStream contentStream && contentStream._connection?._stream is Stream innerStream) 657static IPEndPoint? GetRemoteEndPoint(Stream stream) => (stream as NetworkStream)?.Socket?.RemoteEndPoint as IPEndPoint; 660private async ValueTask<Stream> ConnectToTcpHostAsync(string host, int port, HttpRequestMessage initialRequest, bool async, CancellationToken cancellationToken) 665Stream? stream = null; 671ValueTask<Stream> streamTask = Settings._connectCallback(new SocketsHttpConnectionContext(endPoint, initialRequest), cancellationToken); 738private async ValueTask<Stream> ApplyPlaintextFilterAsync(bool async, Stream stream, Version httpVersion, HttpRequestMessage request, CancellationToken cancellationToken) 745Stream newStream; 748ValueTask<Stream> streamTask = Settings._plaintextStreamFilter(new SocketsHttpPlaintextStreamFilterContext(stream, httpVersion, request), cancellationToken); 781private async ValueTask<Stream> EstablishProxyTunnelAsync(bool async, CancellationToken cancellationToken) 811private async ValueTask<Stream> EstablishSocksTunnel(HttpRequestMessage request, bool async, CancellationToken cancellationToken) 815Stream stream = await ConnectToTcpHostAsync(_proxyUri.IdnHost, _proxyUri.Port, request, async, cancellationToken).ConfigureAwait(false);

System\Net\Http\SocketsHttpHandler\ConnectionPool\HttpConnectionPool.Http1.cs (3)

296(Stream stream, TransportContext? transportContext, Activity? activity, IPEndPoint? remoteEndPoint) = await ConnectAsync(request, async, cancellationToken).ConfigureAwait(false); 300private async ValueTask<HttpConnection> ConstructHttp11ConnectionAsync(bool async, Stream stream, TransportContext? transportContext, HttpRequestMessage request, Activity? activity, IPEndPoint? remoteEndPoint, CancellationToken cancellationToken) 302Stream newStream = await ApplyPlaintextFilterAsync(async, stream, HttpVersion.Version11, request, cancellationToken).ConfigureAwait(false);

System\Net\Http\SocketsHttpHandler\ConnectionPool\HttpConnectionPool.Http2.cs (3)

187(Stream stream, TransportContext? transportContext, Activity? activity, IPEndPoint? remoteEndPoint) = await ConnectAsync(queueItem.Request, true, cts.Token).ConfigureAwait(false); 246private async ValueTask<Http2Connection> ConstructHttp2ConnectionAsync(Stream stream, HttpRequestMessage request, Activity? activity, IPEndPoint? remoteEndPoint, CancellationToken cancellationToken) 289private async Task HandleHttp11Downgrade(HttpRequestMessage request, Stream stream, TransportContext? transportContext, Activity? activity, IPEndPoint? remoteEndPoint, CancellationToken cancellationToken)

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

119public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)

System\Net\Http\SocketsHttpHandler\DecompressionHandler.cs (29)

System\Net\Http\SocketsHttpHandler\Http2Connection.cs (2)

28private readonly Stream _stream; 133public Http2Connection(HttpConnectionPool pool, Stream stream, Activity? connectionSetupActivity, IPEndPoint? remoteEndPoint)

System\Net\Http\SocketsHttpHandler\Http2Stream.cs (6)

1186public void CopyTo(HttpResponseMessage responseMessage, Stream destination, int bufferSize) 1222public async Task CopyToAsync(HttpResponseMessage responseMessage, Stream destination, int bufferSize, CancellationToken cancellationToken) 1527public override void CopyTo(Stream destination, int bufferSize) => throw new NotSupportedException(SR.net_http_content_writeonly_stream); 1529public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken) => Task.FromException(new NotSupportedException(SR.net_http_content_writeonly_stream)); 1622public override void CopyTo(Stream destination, int bufferSize) 1629public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)

System\Net\Http\SocketsHttpHandler\Http3Connection.cs (2)

633await stream.CopyToAsync(Stream.Null).ConfigureAwait(false); 645await stream.CopyToAsync(Stream.Null).ConfigureAwait(false);

System\Net\Http\SocketsHttpHandler\HttpConnection.cs (8)

45internal readonly Stream _stream; 74Stream stream, 779Stream responseStream; 1857private ValueTask CopyFromBufferAsync(Stream destination, bool async, int count, CancellationToken cancellationToken) 1877private Task CopyToUntilEofAsync(Stream destination, bool async, int bufferSize, CancellationToken cancellationToken) 1895private async Task CopyToUntilEofWithExistingBufferedDataAsync(Stream destination, bool async, int bufferSize, CancellationToken cancellationToken) 1913private async Task CopyToContentLengthAsync(Stream destination, bool async, ulong length, int bufferSize, CancellationToken cancellationToken) 2077Stream stream = response.Content.ReadAsStream(cancellationToken);

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

147protected void TraceConnection(Stream stream)

System\Net\Http\SocketsHttpHandler\HttpConnectionResponseContent.cs (13)

13private Stream? _stream; 16public void SetStream(Stream stream) 25private Stream ConsumeStream() 36protected override void SerializeToStream(Stream stream, TransportContext? context, 41using (Stream contentStream = ConsumeStream()) 48protected sealed override Task SerializeToStreamAsync(Stream stream, TransportContext? context) => 51protected sealed override Task SerializeToStreamAsync(Stream stream, TransportContext? context, CancellationToken cancellationToken) 56async Task Impl(Stream stream, CancellationToken cancellationToken) 58using (Stream contentStream = ConsumeStream()) 72protected sealed override Stream CreateContentReadStream(CancellationToken cancellationToken) => 75protected sealed override Task<Stream> CreateContentReadStreamAsync() => 76Task.FromResult<Stream>(ConsumeStream()); 78internal sealed override Stream TryCreateContentReadStream() =>

System\Net\Http\SocketsHttpHandler\HttpConnectionSettings.cs (2)

66internal Func<SocketsHttpConnectionContext, CancellationToken, ValueTask<Stream>>? _connectCallback; 67internal Func<SocketsHttpPlaintextStreamFilterContext, CancellationToken, ValueTask<Stream>>? _plaintextStreamFilter;

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

38public sealed override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken) => throw new NotSupportedException();

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

92public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)

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

401public Func<SocketsHttpConnectionContext, CancellationToken, ValueTask<Stream>>? ConnectCallback 414public Func<SocketsHttpPlaintextStreamFilterContext, CancellationToken, ValueTask<Stream>>? PlaintextStreamFilter

System\Net\Http\SocketsHttpHandler\SocketsHttpPlaintextStreamFilterContext.cs (3)

13private readonly Stream _plaintextStream; 17internal SocketsHttpPlaintextStreamFilterContext(Stream plaintextStream, Version negotiatedHttpVersion, HttpRequestMessage initialRequestMessage) 27public Stream PlaintextStream => _plaintextStream;

System\Net\Http\SocketsHttpHandler\SocksHelper.cs (6)

32public static async ValueTask EstablishSocksTunnelAsync(Stream stream, string host, int port, Uri proxyUri, ICredentials? proxyCredentials, bool async, CancellationToken cancellationToken) 34using (cancellationToken.Register(s => ((Stream)s!).Dispose(), stream)) 65private static async ValueTask EstablishSocks5TunnelAsync(Stream stream, string host, int port, NetworkCredential? credentials, bool async) 213private static async ValueTask EstablishSocks4TunnelAsync(Stream stream, bool isVersion4a, string host, int port, NetworkCredential? credentials, bool async, CancellationToken cancellationToken) 341private static ValueTask WriteAsync(Stream stream, Memory<byte> buffer, bool async) 354private static async ValueTask ReadToFillAsync(Stream stream, Memory<byte> buffer, bool async)

System\Net\Http\StreamContent.cs (13)

15private Stream _content; 20public StreamContent(Stream content) 28public StreamContent(Stream content, int bufferSize) 37private void InitializeContent(Stream content, int bufferSize) 48protected override void SerializeToStream(Stream stream, TransportContext? context, CancellationToken cancellationToken) 56protected override Task SerializeToStreamAsync(Stream stream, TransportContext? context) => 59protected override Task SerializeToStreamAsync(Stream stream, TransportContext? context, CancellationToken cancellationToken) => 65private Task SerializeToStreamAsyncCore(Stream stream, CancellationToken cancellationToken) 100protected override Stream CreateContentReadStream(CancellationToken cancellationToken) 106protected override Task<Stream> CreateContentReadStreamAsync() 110return Task.FromResult<Stream>(new ReadOnlyStream(_content)); 113internal override Stream? TryCreateContentReadStream() => 149public ReadOnlyStream(Stream innerStream) : base(innerStream)

System\Net\Http\StreamToStreamCopy.cs (6)

23public static void Copy(Stream source, Stream destination, int bufferSize, bool disposeSource) 50public static Task CopyAsync(Stream source, Stream destination, int bufferSize, bool disposeSource, CancellationToken cancellationToken = default(CancellationToken)) 80static async Task DisposeSourceAsync(Task copyTask, Stream source) 96private static void DisposeSource(Stream source)

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

105protected override Task SerializeToStreamAsync(Stream stream, TransportContext? context, CancellationToken cancellationToken) => 111internal override Stream? TryCreateContentReadStream() =>

System\Net\Http\Json\HttpClientJsonExtensions.cs (8)

37Func<Stream, TJsonOptions, CancellationToken, ValueTask<TValue?>> deserializeMethod, 78Func<Stream, TJsonOptions, CancellationToken, ValueTask<TValue?>> deserializeMethod, 89using Stream readStream = await GetHttpResponseStreamAsync(client, response, usingResponseHeadersRead, cancellationToken) 115private static ValueTask<Stream> GetHttpResponseStreamAsync( 129ValueTask<Stream> task = HttpContentJsonExtensions.GetContentStreamAsync(response.Content, cancellationToken); 136private static async ValueTask<Stream> GetLengthLimitReadStreamAsync(HttpClient client, ValueTask<Stream> task) 138Stream contentStream = await task.ConfigureAwait(false);

System\Net\Http\Json\HttpClientJsonExtensions.Get.AsyncEnumerable.cs (1)

166using Stream readStream = await GetHttpResponseStreamAsync(client, response, false, cancellationToken)

System\Net\Http\Json\HttpContentJsonExtensions.AsyncEnumerable.cs (1)

104using Stream contentStream = await GetContentStreamAsync(content, cancellationToken)

System\Net\Http\Json\HttpContentJsonExtensions.cs (9)

92using (Stream contentStream = await GetContentStreamAsync(content, cancellationToken).ConfigureAwait(false)) 102using (Stream contentStream = await GetContentStreamAsync(content, cancellationToken).ConfigureAwait(false)) 130using (Stream contentStream = await GetContentStreamAsync(content, cancellationToken).ConfigureAwait(false)) 138using (Stream contentStream = await GetContentStreamAsync(content, cancellationToken).ConfigureAwait(false)) 144internal static ValueTask<Stream> GetContentStreamAsync(HttpContent content, CancellationToken cancellationToken) 146Task<Stream> task = ReadHttpContentStreamAsync(content, cancellationToken); 153private static async ValueTask<Stream> GetTranscodingStreamAsync(Task<Stream> task, Encoding sourceEncoding) 155Stream contentStream = await task.ConfigureAwait(false);

System\Net\Http\Json\HttpContentJsonExtensions.netcoreapp.cs (3)

13private static Task<Stream> ReadHttpContentStreamAsync(HttpContent content, CancellationToken cancellationToken) 18private static Stream GetTranscodingStream(Stream contentStream, Encoding sourceEncoding)

System\Net\Http\Json\JsonContent.cs (4)

104protected override Task SerializeToStreamAsync(Stream stream, TransportContext? context) 113private Task SerializeToStreamAsyncCore(Stream targetStream, CancellationToken cancellationToken) 122private async Task SerializeToStreamAsyncTranscoding(Stream targetStream, bool async, Encoding targetEncoding, CancellationToken cancellationToken) 126Stream transcodingStream = Encoding.CreateTranscodingStream(targetStream, targetEncoding, Encoding.UTF8, leaveOpen: true);

System\Net\Http\Json\JsonContent.netcoreapp.cs (2)

14protected override void SerializeToStream(Stream stream, TransportContext? context, CancellationToken cancellationToken) 26protected override Task SerializeToStreamAsync(Stream stream, TransportContext? context, CancellationToken cancellationToken)

System\Net\Http\Json\LengthLimitReadStream.cs (2)

12private readonly Stream _innerStream; 16public LengthLimitReadStream(Stream innerStream, int lengthLimit)

System\Net\HttpListenerResponse.cs (1)

117public Stream OutputStream

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

59public ChunkedInputStream(HttpListenerContext context, Stream stream, byte[] buffer, int offset, int length)

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

50private readonly Stream _stream; 142public Stream ConnectedStream => _stream;

System\Net\Managed\HttpListener.Certificates.cs (1)

14internal static SslStream CreateSslStream(Stream innerStream, bool ownsStream, RemoteCertificateValidationCallback callback)

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

64private Stream? _inputStream; 318public Stream InputStream 327_inputStream = Stream.Null;

System\Net\Managed\HttpRequestStream.Managed.cs (3)

49private readonly Stream _stream; 51internal HttpRequestStream(Stream stream, byte[] buffer, int offset, int length) 56internal HttpRequestStream(Stream stream, byte[] buffer, int offset, int length, long contentlength)

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

47private readonly Stream _stream; 49internal HttpResponseStream(Stream stream, HttpListenerResponse response, bool ignore_errors)

System\Net\Base64Stream.cs (1)

43internal Base64Stream(Stream stream, Base64WriteStateInfo writeStateInfo) : base(stream)

System\Net\BufferedReadStream.cs (2)

17internal BufferedReadStream(Stream stream) : this(stream, false) 21internal BufferedReadStream(Stream stream, bool readMore) : base(stream)

System\Net\CloseableStream.cs (1)

15internal ClosableStream(Stream stream, EventHandler? onClose) : base(stream)

System\Net\DelegatedStream.cs (3)

12private readonly Stream _stream; 14protected DelegatedStream(Stream stream) 21protected Stream BaseStream

System\Net\Mail\AlternateView.cs (3)

29public AlternateView(Stream contentStream) : 33public AlternateView(Stream contentStream, string? mediaType) : 37public AlternateView(Stream contentStream, ContentType? contentType) :

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

35protected AttachmentBase(Stream contentStream) 40protected AttachmentBase(Stream contentStream, string? mediaType) 45internal AttachmentBase(Stream contentStream, string? name, string? mediaType) 50protected AttachmentBase(Stream contentStream, ContentType? contentType) 73Stream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read); 81Stream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read); 185public Stream ContentStream 321public Attachment(Stream contentStream, string? name) : 328public Attachment(Stream contentStream, string? name, string? mediaType) : 335public Attachment(Stream contentStream, ContentType contentType) :

System\Net\Mail\LinkedResource.cs (3)

27public LinkedResource(Stream contentStream) : 31public LinkedResource(Stream contentStream, string? mediaType) : 35public LinkedResource(Stream contentStream, ContentType? contentType) :

System\Net\Mail\MailWriter.cs (1)

18internal MailWriter(Stream stream, bool encodeForTransport)

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

31private Stream? _stream; 371internal Stream GetClosableStream()

System\Net\Mail\SmtpReplyReaderFactory.cs (1)

35internal SmtpReplyReaderFactory(Stream stream)

System\Net\Mail\SmtpTransport.cs (1)

247private Stream? _stream;

System\Net\Mime\BaseWriter.cs (7)

21protected readonly Stream _stream; 25protected Stream _contentStream = null!; // set to null on dispose 28protected BaseWriter(Stream stream, bool shouldEncodeLeadingDots) 100internal Stream GetContentStream() => GetContentStream(null); 125Stream s = GetContentStream(multiResult); 137internal static Stream EndGetContentStream(IAsyncResult result) 144return (Stream)o;

System\Net\Mime\EightBitStream.cs (2)

39internal EightBitStream(Stream stream) : base(stream) { } 41internal EightBitStream(Stream stream, bool shouldEncodeLeadingDots) : this(stream)

System\Net\Mime\MimeMultiPart.cs (2)

213internal Stream? _outputStream; 224Stream outputStream = writer.GetContentStream();

System\Net\Mime\MimePart.cs (11)

19private Stream? _stream; 33internal Stream? Stream => _stream; 104internal void SetContent(Stream stream) 119internal void SetContent(Stream stream, string? name, string? mimeType) 134internal void SetContent(Stream stream, ContentType? contentType) 234internal Stream GetEncodedStream(Stream stream) 236Stream outputStream = stream; 257Stream outputStream = BaseWriter.EndGetContentStream(result); 297internal Stream? _outputStream; 332Stream outputStream = writer.GetContentStream();

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

20internal MimeWriter(Stream stream, string boundary)

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

69internal QuotedPrintableStream(Stream stream, int lineLength) : base(stream) 76internal QuotedPrintableStream(Stream stream, bool encodeCRLF) : this(stream, EncodedStreamFactory.DefaultMaxLineLength)

System\Net\Quic\QuicStream.cs (1)

30/// <see cref="QuicStream"/> can be used in a same way as any other <see cref="Stream"/>.

System\Net\CommandStream.cs (8)

110internal Stream? SubmitRequest(WebRequest request, bool isAsync, bool readInitalResponseOnConnect) 182protected Stream? ContinueCommandPipeline() 238Stream? stream = null; 254private bool PostSendCommandProcessing(ref Stream? stream) 289private bool PostReadCommandProcessing(ref Stream? stream) 395protected virtual PipelineInstruction PipelineCallback(PipelineEntry? entry, ResponseDescription? response, bool timeout, ref Stream? stream) 453Stream? stream = null; 670Stream? stream = null;

System\Net\FileWebRequest.cs (10)

160Task<Stream> t = Task.Factory.StartNew<Stream>(s => ((FileWebRequest)s!).CreateWriteStream(), 165public override Task<Stream> GetRequestStreamAsync() 168return Task.Factory.StartNew<Stream>(s => 171Stream writeStream = thisRef.CreateWriteStream(); 238public override Stream EndGetRequestStream(IAsyncResult asyncResult) 240Stream stream = TaskToAsyncResult.End<Stream>(asyncResult); 252public override Stream GetRequestStream() 450public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)

System\Net\FileWebResponse.cs (4)

21private Stream _stream; 31_stream = Stream.Null; 117Stream? chkStream = _stream; 126public override Stream GetResponseStream()

System\Net\FtpControlStream.cs (3)

165private PipelineInstruction QueueOrCreateFtpDataStream(ref Stream? stream) 215stream = new FtpDataStream((Stream?)_sslStream ?? _dataStream, _dataStream, (FtpWebRequest)_request!, IsFtpDataStreamWriteable()); 238protected override PipelineInstruction PipelineCallback(PipelineEntry? entry, ResponseDescription? response, bool timeout, ref Stream? stream)

System\Net\FtpDataStream.cs (2)

19private readonly Stream _stream; 28internal FtpDataStream(Stream stream, NetworkStream originalStream, FtpWebRequest request, TriState writeOnly)

System\Net\FtpWebRequest.cs (9)

216private Stream? _stream; 712public override Stream GetRequestStream() 801public override Stream EndGetRequestStream(IAsyncResult asyncResult) 805Stream? requestStream; 853Stream? stream; 989private Stream? TimedSubmitRequestHelper(bool isAsync) 998Stream? stream = null; 1433Stream? stream; 1635Stream? responseStream = _stream;

System\Net\FtpWebResponse.cs (6)

13internal Stream? _responseStream; 24internal FtpWebResponse(Stream? responseStream, long contentLength, Uri responseUri, FtpStatusCode statusCode, string? statusLine, DateTime lastModified, string? bannerMessage, string? welcomeMessage, string? exitMessage) 48public override Stream GetResponseStream() 50Stream? responseStream; 70internal void SetResponseStream(Stream? stream) 72if (stream == null || stream == Stream.Null || stream is EmptyStream)

System\Net\HttpWebRequest.cs (11)

72private Stream? _requestStream; 73private TaskCompletionSource<Stream>? _requestStreamOperation; 1064public override Stream GetRequestStream() 1090private async Task<Stream> InternalGetRequestStream() 1099TaskCompletionSource<Stream> getStreamTcs = new(); 1112public Stream EndGetRequestStream(IAsyncResult asyncResult, out TransportContext? context) 1118public Stream GetRequestStream(out TransportContext? context) 1141public override Stream EndGetRequestStream(IAsyncResult asyncResult) 1145if (asyncResult == null || !(asyncResult is Task<Stream>)) 1155Stream stream; 1158stream = ((Task<Stream>)asyncResult).GetAwaiter().GetResult();

System\Net\HttpWebResponse.cs (5)

337public override Stream GetResponseStream() 342Stream contentStream = _httpResponseMessage.Content.ReadAsStream(); 352return Stream.Null; 384internal sealed class TruncatedReadStream(Stream innerStream, long maxSize) : Stream

System\Net\NetworkStreamWrapper.cs (2)

47internal Stream Stream 51return (Stream?)_sslStream ?? _networkStream;

System\Net\RequestStream.cs (2)

16private readonly Stream _internalStream; 18public RequestStream(Stream internalStream, TaskCompletionSource completeTcs)

System\Net\RequestStreamContent.cs (3)

12internal sealed class RequestStreamContent(TaskCompletionSource<Stream> getStreamTcs, TaskCompletionSource completeTcs) : HttpContent 14protected override Task SerializeToStreamAsync(Stream stream, TransportContext? context) 18protected override async Task SerializeToStreamAsync(Stream stream, TransportContext? context, CancellationToken cancellationToken)

System\Net\WebRequest.cs (4)

488public virtual Stream GetRequestStream() 513public virtual Stream EndGetRequestStream(IAsyncResult asyncResult) 518public virtual async Task<Stream> GetRequestStreamAsync() 523return await Task<Stream>.Factory.FromAsync(

System\Net\WebResponse.cs (2)

108/// <para>When overridden in a derived class, returns the <see cref='System.IO.Stream'/> object used 112public virtual Stream GetResponseStream()

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

235using Stream responseStream = (Stream)readAsStreamMethod.Invoke(content, null)!;

System\Net\Security\AuthenticatedStream.cs (4)

12private readonly Stream _innerStream; 15protected AuthenticatedStream(Stream innerStream, bool leaveInnerStreamOpen) 17if (innerStream == null || innerStream == Stream.Null) 39protected Stream InnerStream

System\Net\Security\NegotiateStream.cs (3)

65public NegotiateStream(Stream innerStream) : this(innerStream, false) 69public NegotiateStream(Stream innerStream, bool leaveInnerStreamOpen) : base(innerStream, leaveInnerStreamOpen) 447static async ValueTask<int> ReadAllAsync(Stream stream, Memory<byte> buffer, bool allowZeroRead, CancellationToken cancellationToken)

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

48public void SslStreamCtor(SslStream sslStream, Stream innerStream)

System\Net\Security\ReadWriteAdapter.cs (12)

System\Net\Security\SslStream.cs (5)

183public SslStream(Stream innerStream) 188public SslStream(Stream innerStream, bool leaveInnerStreamOpen) 193public SslStream(Stream innerStream, bool leaveInnerStreamOpen, RemoteCertificateValidationCallback? userCertificateValidationCallback) 198public SslStream(Stream innerStream, bool leaveInnerStreamOpen, RemoteCertificateValidationCallback? userCertificateValidationCallback, 204public SslStream(Stream innerStream, bool leaveInnerStreamOpen, RemoteCertificateValidationCallback? userCertificateValidationCallback,

System\Net\StreamFramer.cs (2)

24public async ValueTask<byte[]?> ReadMessageAsync<TAdapter>(Stream stream, CancellationToken cancellationToken) 69public async Task WriteMessageAsync<TAdapter>(Stream stream, byte[] message, CancellationToken cancellationToken)

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

27public static Task WriteAsync(IAsyncEnumerable<SseItem<string>> source, Stream destination, CancellationToken cancellationToken = default) 51public static Task WriteAsync<T>(IAsyncEnumerable<SseItem<T>> source, Stream destination, Action<SseItem<T>, IBufferWriter<byte>> itemFormatter, CancellationToken cancellationToken = default) 71private static async Task WriteAsyncCore<T>(IAsyncEnumerable<SseItem<T>> source, Stream destination, Action<SseItem<T>, IBufferWriter<byte>> itemFormatter, CancellationToken cancellationToken)

System\Net\ServerSentEvents\SseParser.cs (3)

25/// This overload has behavior equivalent to calling <see cref="Create{T}(Stream, SseItemParser{T})"/> with a delegate 28public static SseParser<string> Create(Stream sseStream) => 37public static SseParser<T> Create<T>(Stream sseStream, SseItemParser<T> itemParser)

System\Net\ServerSentEvents\SseParser_1.cs (2)

44private readonly Stream _stream; 88internal SseParser(Stream stream, SseItemParser<T> itemParser)

src\libraries\Common\src\System\IO\DelegatingStream.cs (4)

14private readonly Stream _innerStream; 63protected DelegatingStream(Stream innerStream) 125public override void CopyTo(Stream destination, int bufferSize) 130public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)

System\Net\WebClient.cs (28)

358public Stream OpenRead(string address) => 361public Stream OpenRead(Uri address) 385public Stream OpenWrite(string address) => 388public Stream OpenWrite(Uri address) => 391public Stream OpenWrite(string address, string? method) => 394public Stream OpenWrite(Uri address, string? method) 826private byte[]? DownloadBits(WebRequest request, Stream writeStream) 844using (Stream readStream = response.GetResponseStream()) 868WebRequest request, Stream writeStream, 897using (Stream readStream = response.GetResponseStream()) 954using (Stream writeStream = request.GetRequestStream()) 1021using (Stream writeStream = await request.GetRequestStreamAsync().ConfigureAwait(false)) 1203Stream? stream = null; 1560public Task<Stream> OpenReadTaskAsync(string address) => 1563public Task<Stream> OpenReadTaskAsync(Uri address) 1566var tcs = new TaskCompletionSource<Stream>(address); 1585public Task<Stream> OpenWriteTaskAsync(string address) => 1588public Task<Stream> OpenWriteTaskAsync(Uri address) => 1591public Task<Stream> OpenWriteTaskAsync(string address, string? method) => 1594public Task<Stream> OpenWriteTaskAsync(Uri address, string? method) 1597var tcs = new TaskCompletionSource<Stream>(address); 1852public WebClientWriteStream(Stream stream, WebRequest request, WebClient webClient) : base(stream) 1912private readonly Stream? _result; 1914internal OpenReadCompletedEventArgs(Stream? result, Exception? exception, bool cancelled, object? userToken) : base(exception, cancelled, userToken) 1919public Stream Result 1931private readonly Stream? _result; 1933internal OpenWriteCompletedEventArgs(Stream? result, Exception? exception, bool cancelled, object? userToken) : base(exception, cancelled, userToken) 1938public Stream Result

System\Net\WebSockets\ManagedWebSocket.cs (4)

21/// <summary>A managed implementation of a web socket that sends and receives data via a <see cref="Stream"/>.</summary> 43private readonly Stream _stream; 140internal ManagedWebSocket(Stream stream, bool isServer, string? subprotocol, TimeSpan keepAliveInterval, TimeSpan keepAliveTimeout) 204internal ManagedWebSocket(Stream stream, WebSocketCreationOptions options)

System\Net\WebSockets\WebSocket.cs (7)

126/// <summary>Creates a <see cref="WebSocket"/> that operates on a <see cref="Stream"/> representing a web socket connection.</summary> 127/// <param name="stream">The <see cref="Stream"/> for the connection.</param> 132public static WebSocket CreateFromStream(Stream stream, bool isServer, string? subProtocol, TimeSpan keepAliveInterval) 156/// <summary>Creates a <see cref="WebSocket"/> that operates on a <see cref="Stream"/> representing a web socket connection.</summary> 157/// <param name="stream">The <see cref="Stream"/> for the connection.</param> 159public static WebSocket CreateFromStream(Stream stream, WebSocketCreationOptions options) 184public static WebSocket CreateClientWebSocket(Stream innerStream,

System\Net\WebSockets\WebSocketHandle.Managed.cs (1)

193Stream connectedStream = response.Content.ReadAsStream();

src\libraries\System.Private.CoreLib\src\System\IO\BinaryReader.cs (5)

19private readonly Stream _stream; 31public BinaryReader(Stream input) : this(input, Encoding.UTF8, false) 35public BinaryReader(Stream input, Encoding encoding) : this(input, encoding, false) 39public BinaryReader(Stream input, Encoding encoding, bool leaveOpen) 62public virtual Stream BaseStream => _stream;

src\libraries\System.Private.CoreLib\src\System\IO\BinaryWriter.cs (6)

22protected Stream OutStream; 31OutStream = Stream.Null; 37public BinaryWriter(Stream output) : this(output, Encoding.UTF8, false) 41public BinaryWriter(Stream output, Encoding encoding) : this(output, encoding, false) 45public BinaryWriter(Stream output, Encoding encoding, bool leaveOpen) 114public virtual Stream BaseStream

src\libraries\System.Private.CoreLib\src\System\IO\BufferedStream.cs (7)

52private Stream? _stream; // Underlying stream. Close sets _stream to null. 61public BufferedStream(Stream stream) 66public BufferedStream(Stream stream, int bufferSize) 138public Stream UnderlyingStream 1243public override void CopyTo(Stream destination, int bufferSize) 1270public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken) 1281private async Task CopyToAsyncCore(Stream destination, int bufferSize, CancellationToken cancellationToken)

src\libraries\System.Private.CoreLib\src\System\IO\FileStream.cs (3)

533public override void CopyTo(Stream destination, int bufferSize) 540public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken) 635internal Task BaseCopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)

src\libraries\System.Private.CoreLib\src\System\IO\MemoryStream.cs (3)

436public override void CopyTo(Stream destination, int bufferSize) 466public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken) 743public virtual void WriteTo(Stream stream)

src\libraries\System.Private.CoreLib\src\System\IO\Strategies\BufferedFileStreamStrategy.cs (3)

832public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken) 842private async Task CopyToAsyncCore(Stream destination, int bufferSize, CancellationToken cancellationToken) 874public override void CopyTo(Stream destination, int bufferSize)

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

147public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)

src\libraries\System.Private.CoreLib\src\System\IO\Stream.cs (23)

src\libraries\System.Private.CoreLib\src\System\IO\StreamReader.cs (13)

31private readonly Stream _stream; 100_stream = Stream.Null; 104public StreamReader(Stream stream) 109public StreamReader(Stream stream, bool detectEncodingFromByteOrderMarks) 114public StreamReader(Stream stream, Encoding? encoding) 119public StreamReader(Stream stream, Encoding? encoding, bool detectEncodingFromByteOrderMarks) 134public StreamReader(Stream stream, Encoding? encoding, bool detectEncodingFromByteOrderMarks, int bufferSize) 139public StreamReader(Stream stream, Encoding? encoding = null, bool detectEncodingFromByteOrderMarks = true, int bufferSize = -1, bool leaveOpen = false) 271public virtual Stream BaseStream => _stream; 881/// that has been read from the current <see cref="Stream"/> but not stored (by the 1009/// that has been read from the current <see cref="Stream"/> but not stored (by the 1109Stream tmpStream = _stream; 1320Stream tmpStream = _stream;

src\libraries\System.Private.CoreLib\src\System\IO\StreamWriter.cs (7)

33private readonly Stream _stream; 75public StreamWriter(Stream stream) 80public StreamWriter(Stream stream, Encoding? encoding) 89public StreamWriter(Stream stream, Encoding? encoding, int bufferSize) 94public StreamWriter(Stream stream, Encoding? encoding = null, int bufferSize = -1, bool leaveOpen = false) 166_stream = Stream.Null; 342public virtual Stream BaseStream => _stream;

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

113public override void WriteTo(Stream stream) 131public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)

src\libraries\System.Private.CoreLib\src\System\Reflection\Assembly.cs (2)

96public virtual Stream? GetManifestResourceStream(string name) { throw NotImplemented.ByDesign; } 97public virtual Stream? GetManifestResourceStream(Type type, string name) { throw NotImplemented.ByDesign; }

src\libraries\System.Private.CoreLib\src\System\Reflection\Emit\AssemblyBuilder.cs (2)

80public override Stream? GetManifestResourceStream(string name) => 83public override Stream? GetManifestResourceStream(Type type, string name) =>

src\libraries\System.Private.CoreLib\src\System\Resources\ManifestBasedResourceGroveler.cs (5)

41Stream? stream = null; 166internal ResourceSet CreateResourceSet(Stream store, Assembly assembly) 277private static ResourceSet InternalGetResourceSetFromSerializedData(Stream store, string readerTypeName, string? resSetTypeName, ResourceManager.ResourceManagerMediator mediator) 313private static Stream? GetManifestResourceStream(Assembly satellite, string fileName) 326private static Stream? CaseInsensitiveManifestResourceStreamLookup(Assembly satellite, string name)

src\libraries\System.Private.CoreLib\src\System\Resources\ResourceManager.cs (1)

411Stream? stream = MainAssembly.GetManifestResourceStream(fileName);

src\libraries\System.Private.CoreLib\src\System\Resources\ResourceReader.Core.cs (9)

26private static Func<object?, Stream, object>? s_deserializeMethod; 32internal ResourceReader(Stream stream, Dictionary<string, ResourceLocator> resCache, bool permitDeserialization) 105MethodInfo? binaryFormatterDeserialize = binaryFormatterType.GetMethod("Deserialize", [typeof(Stream)]); 106Func<object?, Stream, object>? deserializeMethod = (Func<object?, Stream, object>?) 124private static Func<object, Stream, object> CreateUntypedDelegate<TInstance>(MethodInfo method) 126Func<TInstance, Stream, object> typedDelegate = (Func<TInstance, Stream, object>)Delegate.CreateDelegate(typeof(Func<TInstance, Stream, object>), null, method);

src\libraries\System.Private.CoreLib\src\System\Resources\ResourceReader.cs (1)

118ResourceReader(Stream stream)

src\libraries\System.Private.CoreLib\src\System\Resources\ResourceSet.cs (1)

54public ResourceSet(Stream stream)

src\libraries\System.Private.CoreLib\src\System\Resources\RuntimeResourceSet.cs (1)

183internal RuntimeResourceSet(Stream stream, bool permitDeserialization = false) :

src\libraries\System.Private.CoreLib\src\System\Runtime\Loader\AssemblyLoadContext.cs (4)

375public Assembly LoadFromStream(Stream assembly) 381public Assembly LoadFromStream(Stream assembly, Stream? assemblySymbols) 405static ReadOnlySpan<byte> ReadAllBytes(Stream stream)

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

src\libraries\System.Private.CoreLib\src\System\Text\TranscodingStream.cs (5)

30private Stream _innerStream; // null if the wrapper has been disposed 53internal TranscodingStream(Stream innerStream, Encoding innerEncoding, Encoding thisEncoding, bool leaveOpen) 110Stream innerStream = _innerStream; 137Stream innerStream = _innerStream; 152Stream innerStream = _innerStream;

src\System\Reflection\RuntimeAssembly.cs (2)

283public override Stream? GetManifestResourceStream(Type type, string name) 298public override unsafe Stream? GetManifestResourceStream(string name)

System\Runtime\Serialization\Json\DataContractJsonSerializer.cs (2)

237public override object? ReadObject(Stream stream) 290public override void WriteObject(Stream stream, object? graph)

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

16void SetInput(Stream stream, Encoding? encoding, XmlDictionaryReaderQuotas quotas,

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

12void SetOutput(Stream stream, Encoding encoding, bool ownsStream);

System\Runtime\Serialization\Json\JsonEncodingStreamWrapper.cs (3)

32public JsonEncodingStreamWrapper(Stream stream, Encoding? encoding, bool isReader) 429private void InitForReading(Stream inputStream, Encoding? expectedEncoding) 462private void InitForWriting(Stream outputStream, Encoding writeEncoding)

System\Runtime\Serialization\Json\JsonReaderWriterFactory.cs (7)

17public static XmlDictionaryReader CreateJsonReader(Stream stream, XmlDictionaryReaderQuotas quotas) 29public static XmlDictionaryReader CreateJsonReader(Stream stream, Encoding? encoding, XmlDictionaryReaderQuotas quotas, OnXmlDictionaryReaderClose? onClose) 48public static XmlDictionaryWriter CreateJsonWriter(Stream stream) 53public static XmlDictionaryWriter CreateJsonWriter(Stream stream, Encoding encoding) 58public static XmlDictionaryWriter CreateJsonWriter(Stream stream, Encoding encoding, bool ownsStream) 63public static XmlDictionaryWriter CreateJsonWriter(Stream stream, Encoding encoding, bool ownsStream, bool indent) 68public static XmlDictionaryWriter CreateJsonWriter(Stream stream, Encoding encoding, bool ownsStream, bool indent, string? indentChars)

System\Runtime\Serialization\Json\XmlJsonReader.cs (2)

797public void SetInput(Stream stream, Encoding? encoding, XmlDictionaryReaderQuotas quotas, 811public override void StartCanonicalization(Stream stream, bool includeComments, string[]? inclusivePrefixes)

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

236public void SetOutput(Stream stream, Encoding encoding, bool ownsStream)

System\Runtime\Serialization\XmlObjectSerializer.cs (2)

33public virtual void WriteObject(Stream stream, object? graph) 270public virtual object? ReadObject(Stream stream)

System\Xml\EncodingStreamWrapper.cs (3)

45private readonly Stream _stream; 54public EncodingStreamWrapper(Stream stream, Encoding? encoding) 165public EncodingStreamWrapper(Stream stream, Encoding encoding, bool emitBOM)

System\Xml\IFragmentCapableXmlDictionaryWriter.cs (1)

12void StartFragment(Stream stream, bool generateSelfContainedTextFragment);

System\Xml\IStreamProvider.cs (2)

10Stream GetStream(); 11void ReleaseStream(Stream stream);

System\Xml\XmlBaseReader.cs (1)

2004public override void StartCanonicalization(Stream stream, bool includeComments, string[]? inclusivePrefixes)

System\Xml\XmlBaseWriter.cs (3)

34private Stream? _oldStream; 1586public override void StartCanonicalization(Stream stream, bool includeComments, string[]? inclusivePrefixes) 1619public void StartFragment(Stream stream, bool generateSelfContainedTextFragment)

System\Xml\XmlBinaryReader.cs (2)

19void SetInput(Stream stream, 59public void SetInput(Stream stream,

System\Xml\XmlBinaryWriter.cs (3)

21void SetOutput(Stream stream, IXmlDictionary? dictionary, XmlBinaryWriterSession? session, bool ownsStream); 43public void SetOutput(Stream stream, IXmlDictionary? dictionary, XmlBinaryWriterSession? session, bool ownsStream) 1155public void SetOutput(Stream stream, IXmlDictionary? dictionary, XmlBinaryWriterSession? session, bool ownsStream)

System\Xml\XmlBufferReader.cs (3)

23private Stream? _stream; 74public void SetBuffer(Stream stream, IXmlDictionary? dictionary, XmlBinaryReaderSession? session) 87private void SetBuffer(Stream? stream, byte[] buffer, int offset, int count, IXmlDictionary? dictionary, XmlBinaryReaderSession? session)

System\Xml\XmlCanonicalWriter.cs (1)

57public void SetOutput(Stream stream, bool includeComments, string[]? inclusivePrefixes)

System\Xml\XmlDictionaryAsyncCheckWriter.cs (2)

550public override void StartCanonicalization(Stream stream, bool includeComments, string[]? inclusivePrefixes) 700public void SetOutput(Stream stream, Encoding encoding, bool ownsStream)

System\Xml\XmlDictionaryReader.cs (11)

System\Xml\XmlDictionaryWriter.cs (11)

System\Xml\XmlSigningNodeWriter.cs (1)

24public void SetOutput(XmlNodeWriter writer, Stream stream, bool includeComments, string[]? inclusivePrefixes)

System\Xml\XmlStreamNodeWriter.cs (2)

30protected void SetOutput(Stream stream, bool ownsStream, Encoding? encoding) 41public Stream OutputStream { get; set; }

System\Xml\XmlUTF8TextReader.cs (2)

21void SetInput(Stream stream, Encoding? encoding, XmlDictionaryReaderQuotas quotas, OnXmlDictionaryReaderClose? onClose); 572public void SetInput(Stream stream, Encoding? encoding, XmlDictionaryReaderQuotas quotas, OnXmlDictionaryReaderClose? onClose)

System\Xml\XmlUTF8TextWriter.cs (3)

13void SetOutput(Stream stream, Encoding encoding, bool ownsStream); 20public void SetOutput(Stream stream, Encoding encoding, bool ownsStream) 90public new void SetOutput(Stream stream, bool ownsStream, Encoding? encoding)

System\IO\BinaryReaderExtensions.cs (1)

53Stream stream = reader.BaseStream;

System\IO\StreamExtensions.cs (1)

14internal static ComScope<IStream> ToIStream(this Stream stream, bool makeSeekable = false)

System\Private\Windows\BinaryFormat\BinaryFormatWriter.cs (35)

System\Private\Windows\BinaryFormat\Support\BinaryFormatWriterScope.cs (1)

13public BinaryFormatWriterScope(Stream stream)

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

97public static bool TryWriteObject(Stream stream, object value) =>

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

14static abstract bool TryWriteObject(Stream stream, object value);

System\Private\Windows\Nrbf\SerializationRecordExtensions.cs (3)

19/// <inheritdoc cref="DecodeNrbf(Stream, out IReadOnlyDictionary{SerializationRecordId, SerializationRecord})"/> 20internal static SerializationRecord DecodeNrbf(this Stream stream) => stream.DecodeNrbf(out _); 25internal static SerializationRecord DecodeNrbf(this Stream stream, out IReadOnlyDictionary<SerializationRecordId, SerializationRecord> recordMap)

System\Private\Windows\Ole\Composition.ManagedToNativeAdapter.cs (2)

273_ when data is Stream dataStream 305static HRESULT SaveStreamToHGLOBAL(ref HGLOBAL hglobal, Stream stream)

System\Private\Windows\Runtime.cs (1)

38static bool INrbfSerializer.TryWriteObject(Stream stream, object value) =>

Windows\Win32\System\Com\ComManagedStream.cs (3)

10private readonly Stream _dataStream; 15internal ComManagedStream(Stream stream, bool makeSeekable = false) 43public Stream GetDataStream() => _dataStream;

System\Drawing\CoreImageExtensions.cs (1)

13internal static void Save(this IImage image, Stream stream, Guid encoder, Guid format, EncoderParameters* encoderParameters)

System\Xml\BinaryXml\XmlBinaryReader.cs (2)

250private Stream _inStrm; 320public XmlSqlBinaryReader(Stream stream, byte[] data, int len, string baseUri, bool closeInput, XmlReaderSettings settings)

System\Xml\Core\HtmlEncodedRawTextWriter.cs (2)

32public HtmlEncodedRawTextWriter(Stream stream, XmlWriterSettings settings) : base(stream, settings) 795public HtmlEncodedRawTextWriterIndent(Stream stream, XmlWriterSettings settings) : base(stream, settings)

System\Xml\Core\HtmlUtf8RawTextWriter.cs (2)

27public HtmlUtf8RawTextWriter(Stream stream, XmlWriterSettings settings) : base(stream, settings) 767public HtmlUtf8RawTextWriterIndent(Stream stream, XmlWriterSettings settings) : base(stream, settings)

System\Xml\Core\TextEncodedRawTextWriter.cs (1)

29public TextEncodedRawTextWriter(Stream stream, XmlWriterSettings settings) : base(stream, settings)

System\Xml\Core\TextUtf8RawTextWriter.cs (1)

24public TextUtf8RawTextWriter(Stream stream, XmlWriterSettings settings) : base(stream, settings)

System\Xml\Core\XmlAutoDetectWriter.cs (2)

25private readonly Stream? _strm; 48public XmlAutoDetectWriter(Stream strm, XmlWriterSettings writerSettings)

System\Xml\Core\XmlEncodedRawTextWriter.cs (3)

30protected Stream? _stream; 134public XmlEncodedRawTextWriter(Stream stream, XmlWriterSettings settings) : this(settings) 1927public XmlEncodedRawTextWriterIndent(Stream stream, XmlWriterSettings settings) : base(stream, settings)

System\Xml\Core\XmlReader.cs (6)

1632public static XmlReader Create(Stream input) 1642public static XmlReader Create(Stream input, XmlReaderSettings? settings) 1648public static XmlReader Create(Stream input, XmlReaderSettings? settings, string? baseUri) 1655public static XmlReader Create(Stream input, XmlReaderSettings? settings, XmlParserContext? inputContext) 1701internal static XmlReader CreateSqlReader(Stream input, XmlReaderSettings? settings, XmlParserContext inputContext) 1744internal static int CalcBufferSize(Stream input)

System\Xml\Core\XmlReaderSettings.cs (1)

343internal XmlReader CreateReader(Stream input, Uri? baseUri, string? baseUriString, XmlParserContext? inputContext)

System\Xml\Core\XmlTextReader.cs (5)

38public XmlTextReader(Stream input) 44public XmlTextReader([StringSyntax(StringSyntaxAttribute.Uri)] string url, Stream input) 50public XmlTextReader(Stream input, XmlNameTable nt) 56public XmlTextReader([StringSyntax(StringSyntaxAttribute.Uri)] string url, Stream input, XmlNameTable nt) 86public XmlTextReader(Stream xmlFragment, XmlNodeType fragType, XmlParserContext? context)

System\Xml\Core\XmlTextReaderImpl.cs (23)

122public Stream? inputStream; 449internal XmlTextReaderImpl(Stream input) : this(string.Empty, input, new NameTable()) 453internal XmlTextReaderImpl(Stream input, XmlNameTable nt) : this(string.Empty, input, nt) 457internal XmlTextReaderImpl(string url, Stream input) : this(url, input, new NameTable()) 461internal XmlTextReaderImpl(string? url, Stream input, XmlNameTable nt) : this(nt) 505internal XmlTextReaderImpl(Stream xmlFragment, XmlNodeType fragType, XmlParserContext? context) 628Stream? stream; 638Task<object> t = _laterInitParam.inputUriResolver.GetEntityAsync(_laterInitParam.inputbaseUri, string.Empty, typeof(Stream)); 639stream = (Stream)t.GetAwaiter().GetResult(); 643stream = (Stream?)_laterInitParam.inputUriResolver.GetEntity(_laterInitParam.inputbaseUri, string.Empty, typeof(Stream)); 682internal XmlTextReaderImpl(Stream stream, byte[]? bytes, int byteCount, XmlReaderSettings settings, Uri? baseUri, string? baseUriStr, 2818private void InitStreamInput(Stream stream, Encoding? encoding) 2823private void InitStreamInput(string baseUriStr, Stream stream, Encoding? encoding) 2829private void InitStreamInput(Uri? baseUri, Stream stream, Encoding? encoding) 2835private void InitStreamInput(Uri? baseUri, string baseUriStr, Stream stream, Encoding? encoding) 2840private void InitStreamInput(Uri? baseUri, string baseUriStr, Stream stream, byte[]? bytes, int byteCount, Encoding? encoding) 3068_ps.stream = (Stream?)tmpResolver.GetEntity(_ps.baseUri, null, typeof(Stream)); 7967Debug.Assert(_xmlResolver.SupportsType(uri, typeof(Stream)), "Stream must always be a supported type in XmlResolver"); 7969Stream? stream = (Stream?)_xmlResolver.GetEntity(uri, null, typeof(Stream));

System\Xml\Core\XmlTextReaderImplAsync.cs (9)

77Stream stream = (Stream)(await _laterInitParam!.inputUriResolver!.GetEntityAsync(_laterInitParam.inputbaseUri!, string.Empty, typeof(Stream)).ConfigureAwait(false)); 860private Task InitStreamInputAsync(Uri baseUri, Stream stream, Encoding? encoding) 866private async Task InitStreamInputAsync(Uri? baseUri, string baseUriStr, Stream stream, byte[]? bytes, int byteCount, Encoding? encoding) 5178Debug.Assert(_xmlResolver.SupportsType(uri, typeof(Stream)), "Stream must always be a supported type in XmlResolver"); 5180Stream stream = (Stream)await _xmlResolver.GetEntityAsync(uri, null, typeof(Stream)).ConfigureAwait(false);

System\Xml\Core\XmlTextReaderImplHelpers.cs (1)

34internal Stream? stream;

System\Xml\Core\XmlTextWriter.cs (2)

280public XmlTextWriter(Stream w, Encoding? encoding) : this() 312public Stream? BaseStream

System\Xml\Core\XmlUtf8RawTextWriter.cs (3)

32protected Stream _stream = null!; 97public XmlUtf8RawTextWriter(Stream stream, XmlWriterSettings settings) : this(settings) 1784public XmlUtf8RawTextWriterIndent(Stream stream, XmlWriterSettings settings) : base(stream, settings)

System\Xml\Core\XmlValidatingReader.cs (1)

39public XmlValidatingReader(Stream xmlFragment, XmlNodeType fragType, XmlParserContext context)

System\Xml\Core\XmlValidatingReaderImpl.cs (1)

182internal XmlValidatingReaderImpl(Stream xmlFragment, XmlNodeType fragType, XmlParserContext? context)

System\Xml\Core\XmlWriter.cs (2)

641public static XmlWriter Create(Stream output) 653public static XmlWriter Create(Stream output, XmlWriterSettings? settings)

System\Xml\Core\XmlWriterSettings.cs (1)

360internal XmlWriter CreateWriter(Stream output)

System\Xml\Dom\XmlDocument.cs (2)

1283public virtual void Load(Stream inStream) 1408public virtual void Save(Stream outStream)

System\Xml\Dom\XmlDomTextWriter.cs (1)

14public XmlDOMTextWriter(Stream w, Encoding? encoding) : base(w, encoding)

System\Xml\IApplicationResourceStreamResolver.cs (1)

17Stream GetApplicationResourceStream(Uri relativeUri);

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

28internal abstract Stream AsStream(); 39if (type == null || type == typeof(Stream)) 64internal override Stream AsStream() 89internal override Stream AsStream() 104internal override Stream AsStream() 240if (ofObjectToReturn == null || ofObjectToReturn == typeof(Stream) || ofObjectToReturn == typeof(object)) 302public void Add(Uri uri, Stream value)

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

33if (ofObjectToReturn == null || ofObjectToReturn == typeof(Stream) || ofObjectToReturn == typeof(object))

System\Xml\Schema\Preprocessor.cs (2)

360if (returnType.IsSubclassOf(typeof(Stream))) 364reader = XmlReader.Create((Stream)obj, _readerSettings, ruri.ToString());

System\Xml\Schema\SchemaCollectionpreProcessor.cs (3)

223Stream? stream = GetSchemaEntity(ruri); 1806private Stream? GetSchemaEntity(Uri ruri) 1810return (Stream?)_xmlResolver!.GetEntity(ruri, null, null);

System\Xml\Schema\XdrBuilder.cs (2)

524Stream stm = (Stream)_xmlResolver.GetEntity(ruri, null, null)!;

System\Xml\Schema\XdrValidator.cs (2)

345Stream stm = (Stream)this.XmlResolver.GetEntity(ruri, null, null)!;

System\Xml\Schema\XmlSchema.cs (3)

65public static XmlSchema? Read(Stream stream, ValidationEventHandler? validationEventHandler) 97public void Write(Stream stream) 104public void Write(Stream stream, XmlNamespaceManager? namespaceManager)

System\Xml\Schema\XmlSchemaValidator.cs (2)

1847Stream stm = (Stream)_xmlResolver.GetEntity(ruri, null, null)!;

System\Xml\Schema\XsdValidator.cs (2)

578Stream stm = (Stream)this.XmlResolver.GetEntity(ruri, null, null)!;

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

301internal static bool GenerateSerializerToStream(XmlMapping[] xmlMappings, Type?[] types, string? defaultNamespace, Assembly? assembly, Hashtable assemblies, Stream stream)

System\Xml\Serialization\XmlSerializer.cs (4)

349public void Serialize(Stream stream, object? o) 356public void Serialize(Stream stream, object? o, XmlSerializerNamespaces? namespaces) 445public object? Deserialize(Stream stream) 666internal static bool GenerateSerializer(Type[]? types, XmlMapping[] mappings, Stream stream)

System\Xml\XmlDownloadManager.cs (5)

13internal static Stream GetStream(Uri uri, ICredentials? credentials, IWebProxy? proxy) 27internal static Task<Stream> GetStreamAsync(Uri uri, ICredentials? credentials, IWebProxy? proxy) 32return Task.FromResult<Stream>(new FileStream(fileUri.LocalPath, FileMode.Open, FileAccess.Read, FileShare.Read, 1, useAsync: true)); 40private static async Task<Stream> GetNonFileStreamAsync(Uri uri, ICredentials? credentials, IWebProxy? proxy) 56using (Stream respStream = await client.GetStreamAsync(uri).ConfigureAwait(false))

System\Xml\XmlResolver.cs (1)

83if (type == null || type == typeof(Stream))

System\Xml\XmlResolver.FileSystemResolver.cs (2)

31if ((ofObjectToReturn is null || ofObjectToReturn == typeof(Stream) || ofObjectToReturn == typeof(object)) 42if (ofObjectToReturn == null || ofObjectToReturn == typeof(Stream) || ofObjectToReturn == typeof(object))

System\Xml\XmlUrlResolver.cs (2)

41if (ofObjectToReturn is null || ofObjectToReturn == typeof(Stream) || ofObjectToReturn == typeof(object)) 52if (ofObjectToReturn == null || ofObjectToReturn == typeof(Stream) || ofObjectToReturn == typeof(object))

System\Xml\XPath\XPathDocument.cs (1)

98public XPathDocument(Stream stream)

System\Xml\Xsl\QueryReaderSettings.cs (1)

87public XmlReader CreateReader(Stream stream, string? baseUri)

System\Xml\Xsl\Runtime\XmlQueryContext.cs (2)

168Stream? stream = dataSource as Stream;

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

406public XmlQueryDataReader(Stream input) : base(input) { } 435public XmlQueryDataWriter(Stream output) : base(output) { }

System\Xml\Xsl\XmlQueryTypeFactory.cs (1)

1164type.GetObjectData(new BinaryWriter(Stream.Null));

System\Xml\Xsl\Xslt\XsltLoader.cs (2)

204Stream? stream = input as Stream;

System\Xml\Xsl\XsltOld\Compiler.cs (2)

584if (input is Stream) 586XmlTextReaderImpl tr = new XmlTextReaderImpl(resolved, (Stream)input);

System\Xml\Xsl\XsltOld\Processor.cs (3)

178if (input is Stream) 180XmlTextReaderImpl tr = new XmlTextReaderImpl(ruri.ToString(), (Stream)input); 386public void Execute(Stream stream)

System\Xml\Xsl\XsltOld\TextOnlyOutput.cs (1)

27internal TextOnlyOutput(Processor processor, Stream stream)

System\Xml\Xsl\XsltOld\TextOutput.cs (1)

16internal TextOutput(Processor processor, Stream stream)

System\Xml\Xslt\XslCompiledTransform.cs (3)

267public void Transform(IXPathNavigable input, XsltArgumentList? arguments, Stream results) 305public void Transform(XmlReader input, XsltArgumentList? arguments, Stream results) 349public void Transform(string inputUri, XsltArgumentList? arguments, Stream results)

System\Xml\Xslt\XslTransform.cs (4)

139public void Transform(XPathNavigator input, XsltArgumentList? args, Stream output, XmlResolver? resolver) 146public void Transform(XPathNavigator input, XsltArgumentList? args, Stream output) 192public void Transform(IXPathNavigable input, XsltArgumentList? args, Stream output, XmlResolver? resolver) 199public void Transform(IXPathNavigable input, XsltArgumentList? args, Stream output)

System\Xml\Linq\XDocument.cs (24)

System\Xml\Linq\XElement.cs (24)

System\Xml\Linq\XStreamingElement.cs (6)

98/// Save the contents of an <see cref="XStreamingElement"/> to a <see cref="Stream"/> 101/// <param name="stream"><see cref="Stream"/> to write to </param> 102public void Save(Stream stream) 108/// Save the contents of an <see cref="XStreamingElement"/> to a <see cref="Stream"/>, 111/// <param name="stream"><see cref="Stream"/> to write to </param> 116public void Save(Stream stream, SaveOptions options)

System\Reflection\Context\Delegation\DelegatingAssembly.cs (2)

148public override Stream? GetManifestResourceStream(string name) 153public override Stream? GetManifestResourceStream(Type type, string name)

System\Reflection\Emit\PersistedAssemblyBuilder.cs (5)

53private void WritePEImage(Stream peStream, BlobBuilder ilBuilder, BlobBuilder fieldData) 74/// Serializes the assembly to <see cref="Stream"/>. 76/// <param name="stream">The <see cref="Stream"/> to which the assembly serialized.</param> 80public void Save(Stream stream) => SaveInternal(stream); 97private void SaveInternal(Stream stream)

System\Reflection\Internal\MemoryBlocks\AbstractMemoryBlock.cs (1)

30public unsafe Stream GetStream() => new UnmanagedMemoryStream(Pointer, Size);

System\Reflection\Internal\MemoryBlocks\MemoryBlockProvider.cs (2)

43/// Gets the <see cref="Stream"/> backing the <see cref="MemoryBlockProvider"/>, if there is one. 50public virtual bool TryGetUnderlyingStream([NotNullWhen(true)] out Stream? stream, out long imageStart, out int imageSize, [NotNullWhen(true)] out object? streamGuard)

System\Reflection\Internal\MemoryBlocks\StreamMemoryBlockProvider.cs (4)

27private Stream _stream; 38public StreamMemoryBlockProvider(Stream stream, long imageStart, int imageSize, bool leaveOpen) 69internal static unsafe NativeHeapMemoryBlock ReadMemoryBlockNoLock(Stream stream, long start, int size) 91public override bool TryGetUnderlyingStream([NotNullWhen(true)] out Stream? stream, out long imageStart, out int imageSize, [NotNullWhen(true)] out object? streamGuard)

System\Reflection\Internal\Utilities\StreamExtensions.cs (4)

20/// Unlike <see cref="Stream.Read(byte[], int, int)"/> it is not guaranteed that 24internal static int TryReadAll(this Stream stream, byte[] buffer, int offset, int count) 50internal static int TryReadAll(this Stream stream, Span<byte> buffer) 78internal static int GetAndValidateSize(Stream stream, int size, string streamParameterName)

System\Reflection\Internal\Utilities\StreamExtensions.netcoreapp.cs (1)

10internal static unsafe void ReadExactly(this Stream stream, byte* buffer, int size)

System\Reflection\Metadata\BlobBuilder.cs (2)

336public void WriteContentTo(Stream destination) 694public int TryWriteBytes(Stream source, int byteCount)

System\Reflection\Metadata\BlobWriter.cs (1)

169public int WriteBytes(Stream source, int byteCount)

System\Reflection\Metadata\MetadataReaderProvider.cs (2)

137public static MetadataReaderProvider FromPortablePdbStream(Stream stream, MetadataStreamOptions options = MetadataStreamOptions.Default, int size = 0) => FromMetadataStream(stream, options, size); 163public static MetadataReaderProvider FromMetadataStream(Stream stream, MetadataStreamOptions options = MetadataStreamOptions.Default, int size = 0)

System\Reflection\PortableExecutable\PEBinaryReader.cs (1)

26public PEBinaryReader(Stream stream, int size)

System\Reflection\PortableExecutable\PEHeaders.cs (3)

43public PEHeaders(Stream peStream) 58public PEHeaders(Stream peStream, int size) 74public PEHeaders(Stream peStream, int size, bool isLoadedImage)

System\Reflection\PortableExecutable\PEReader.cs (10)

100public PEReader(Stream peStream) 128public PEReader(Stream peStream, PEStreamOptions options) 156public unsafe PEReader(Stream peStream, PEStreamOptions options, int size) 316if (peImage.TryGetUnderlyingStream(out Stream? stream, out long imageStart, out int imageSize, out object? streamGuard)) 681/// If specified, called to open a <see cref="Stream"/> for a given file path. 682/// The provider is expected to either return a readable and seekable <see cref="Stream"/>, 710public bool TryOpenAssociatedPortablePdb(string peImagePath, Func<string, Stream?> pdbFileStreamProvider, out MetadataReaderProvider? pdbReaderProvider, out string? pdbPath) 768private bool TryOpenCodeViewPortablePdb(DebugDirectoryEntry codeViewEntry, string peImageDirectory, Func<string, Stream?> pdbFileStreamProvider, out MetadataReaderProvider? provider, out string? pdbPath, ref Exception? errorToReport) 803private static bool TryOpenPortablePdbFile(string path, BlobContentId id, Func<string, Stream?> pdbFileStreamProvider, out MetadataReaderProvider? provider, ref Exception? errorToReport) 810Stream? pdbStream;

System\Reflection\MetadataLoadContext.Apis.cs (1)

161public Assembly LoadFromStream(Stream assembly)

System\Reflection\MetadataLoadContext.Loading.cs (1)

20private RoAssembly LoadFromStreamCore(Stream peStream)

System\Reflection\TypeLoading\Assemblies\Ecma\EcmaAssembly.ManifestResources.cs (1)

62public sealed override Stream? GetManifestResourceStream(string name)

System\Reflection\TypeLoading\Assemblies\Ecma\EcmaAssembly.Modules.cs (1)

52protected sealed override RoModule CreateModule(Stream peStream, bool containsMetadata)

System\Reflection\TypeLoading\Assemblies\RoAssembly.cs (2)

174public abstract override Stream? GetManifestResourceStream(string name); 175public sealed override Stream? GetManifestResourceStream(Type type, string name)

System\Reflection\TypeLoading\Assemblies\RoAssembly.Modules.cs (1)

137protected abstract RoModule CreateModule(Stream peStream, bool containsMetadata);

System\Reflection\TypeLoading\Assemblies\RoStubAssembly.cs (2)

22public sealed override Stream GetManifestResourceStream(string name) => throw null!; 29protected sealed override RoModule CreateModule(Stream peStream, bool containsMetadata) => throw null!;

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

40private Stream _output; 63PreserializedResourceWriter(Stream stream) 119if (value != null && value is Stream) 121AddResourceInternal(name, (Stream)value, false); 135public void AddResource(string name, Stream? value, bool closeAfterWrite = false) 150private void AddResourceInternal(string name, Stream? value, bool closeAfterWrite) 221internal readonly Stream Stream; 224internal StreamWrapper(Stream s, bool closeAfterWrite) 317Stream dataSection = new MemoryStream(); // Either a FileStream or a MemoryStream 613Stream s = sw.Stream;

src\libraries\System.Private.CoreLib\src\System\Resources\ResourceReader.cs (1)

116DeserializingResourceReader(Stream stream)

System\Resources\Extensions\BinaryFormat\BinaryFormattedObject.cs (1)

42public BinaryFormattedObject(Stream stream, Options? options = null)

System\Resources\Extensions\DeserializingResourceReader.cs (1)

202Stream stream;

System\Resources\Extensions\PreserializedResourceWriter.cs (3)

189public void AddActivatorResource(string name, Stream value, string typeName, bool closeAfterWrite = false) 258Stream stream = (Stream)record.Data;

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

40private Stream _output; 65ResourceWriter(Stream stream) 119if (value != null && value is Stream) 121AddResourceInternal(name, (Stream)value, false); 135public void AddResource(string name, Stream? value, bool closeAfterWrite = false) 150private void AddResourceInternal(string name, Stream? value, bool closeAfterWrite) 221internal readonly Stream Stream; 224internal StreamWrapper(Stream s, bool closeAfterWrite) 317Stream dataSection = new MemoryStream(); // Either a FileStream or a MemoryStream 613Stream s = sw.Stream;

System\Resources\ResourceWriter.core.cs (1)

25public void AddResource(string name, Stream? value)

artifacts\obj\System.Runtime\Debug\net10.0\System.Runtime.Forwards.cs (1)

323[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.IO.Stream))]

System\Runtime\Serialization\Formatter.cs (2)

26public abstract object Deserialize(Stream serializationStream); 66public abstract void Serialize(Stream serializationStream, object graph);

System\Runtime\Serialization\Formatters\Binary\BinaryFormatter.Removed.cs (2)

13public object Deserialize(Stream serializationStream) 17public void Serialize(Stream serializationStream, object graph)

System\Runtime\Serialization\IFormatter.cs (2)

17object Deserialize(Stream serializationStream); 19void Serialize(Stream serializationStream, object graph);

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

235using Stream responseStream = (Stream)readAsStreamMethod.Invoke(content, null)!;

System\Security\Cryptography\Cng.NotSupported.cs (2)

324public byte[] SignData(System.IO.Stream data) => null!; 329public bool VerifyData(System.IO.Stream data, byte[] signature) => false;

System\Security\Cryptography\CryptographicOperations.cs (11)

226public static byte[] HashData(HashAlgorithmName hashAlgorithm, Stream source) 262public static int HashData(HashAlgorithmName hashAlgorithm, Stream source, Span<byte> destination) 310Stream source, 359Stream source, 542public static byte[] HmacData(HashAlgorithmName hashAlgorithm, byte[] key, Stream source) 574public static byte[] HmacData(HashAlgorithmName hashAlgorithm, ReadOnlySpan<byte> key, Stream source) 612public static int HmacData(HashAlgorithmName hashAlgorithm, ReadOnlySpan<byte> key, Stream source, Span<byte> destination) 657Stream source, 702Stream source, 749Stream source, 759private static void CheckStream([NotNull] Stream source)

System\Security\Cryptography\CryptoStream.cs (7)

17private readonly Stream _stream; 33public CryptoStream(Stream stream, ICryptoTransform transform, CryptoStreamMode mode) 38public CryptoStream(Stream stream, ICryptoTransform transform, CryptoStreamMode mode, bool leaveOpen) 685public override unsafe void CopyTo(Stream destination, int bufferSize) 713public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken) 719private async Task CopyToAsyncInternal(Stream destination, int bufferSize, CancellationToken cancellationToken) 742private void CheckCopyToArguments(Stream destination, int bufferSize)

System\Security\Cryptography\DSA.cs (7)

92protected virtual byte[] HashData(Stream data, HashAlgorithmName hashAlgorithm) => 241public virtual byte[] SignData(Stream data, HashAlgorithmName hashAlgorithm) 271public byte[] SignData(Stream data, HashAlgorithmName hashAlgorithm, DSASignatureFormat signatureFormat) 293protected virtual byte[] SignDataCore(Stream data, HashAlgorithmName hashAlgorithm, DSASignatureFormat signatureFormat) 384public virtual bool VerifyData(Stream data, byte[] signature, HashAlgorithmName hashAlgorithm) 696Stream data, 724Stream data,

System\Security\Cryptography\DSACryptoServiceProvider.Unix.cs (4)

109protected override byte[] HashData(Stream data, HashAlgorithmName hashAlgorithm) 195public byte[] SignData(Stream inputStream) 211public override byte[] SignData(Stream data, HashAlgorithmName hashAlgorithm) 269public override bool VerifyData(Stream data, byte[] signature, HashAlgorithmName hashAlgorithm)

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

35public override byte[] SignData(Stream data, HashAlgorithmName hashAlgorithm) => 46public override bool VerifyData(Stream data, byte[] signature, HashAlgorithmName hashAlgorithm) => 162protected override byte[] HashData(Stream data, HashAlgorithmName hashAlgorithm) =>

System\Security\Cryptography\ECDsa.cs (7)

232public byte[] SignData(Stream data, HashAlgorithmName hashAlgorithm, DSASignatureFormat signatureFormat) 255Stream data, 546public virtual byte[] SignData(Stream data, HashAlgorithmName hashAlgorithm) 915public bool VerifyData(Stream data, byte[] signature, HashAlgorithmName hashAlgorithm) 948Stream data, 977Stream data, 995protected virtual byte[] HashData(Stream data, HashAlgorithmName hashAlgorithm) =>

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

33public override byte[] SignData(Stream data, HashAlgorithmName hashAlgorithm) => 187protected override byte[] HashData(Stream data, HashAlgorithmName hashAlgorithm) =>

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

92public byte[] ComputeHash(Stream inputStream) 118Stream inputStream, 129Stream inputStream,

System\Security\Cryptography\HMACMD5.cs (6)

185public static int HashData(ReadOnlySpan<byte> key, Stream source, Span<byte> destination) 211public static byte[] HashData(ReadOnlySpan<byte> key, Stream source) 234public static byte[] HashData(byte[] key, Stream source) 258public static ValueTask<byte[]> HashDataAsync(ReadOnlyMemory<byte> key, Stream source, CancellationToken cancellationToken = default) 285public static ValueTask<byte[]> HashDataAsync(byte[] key, Stream source, CancellationToken cancellationToken = default) 319Stream source,

System\Security\Cryptography\HMACSHA1.cs (6)

186public static int HashData(ReadOnlySpan<byte> key, Stream source, Span<byte> destination) 211public static byte[] HashData(ReadOnlySpan<byte> key, Stream source) 233public static byte[] HashData(byte[] key, Stream source) 256public static ValueTask<byte[]> HashDataAsync(ReadOnlyMemory<byte> key, Stream source, CancellationToken cancellationToken = default) 282public static ValueTask<byte[]> HashDataAsync(byte[] key, Stream source, CancellationToken cancellationToken = default) 315Stream source,

System\Security\Cryptography\HMACSHA256.cs (6)

178public static int HashData(ReadOnlySpan<byte> key, Stream source, Span<byte> destination) 203public static byte[] HashData(ReadOnlySpan<byte> key, Stream source) 225public static byte[] HashData(byte[] key, Stream source) 248public static ValueTask<byte[]> HashDataAsync(ReadOnlyMemory<byte> key, Stream source, CancellationToken cancellationToken = default) 274public static ValueTask<byte[]> HashDataAsync(byte[] key, Stream source, CancellationToken cancellationToken = default) 307Stream source,

System\Security\Cryptography\HMACSHA3_256.cs (6)

216public static int HashData(ReadOnlySpan<byte> key, Stream source, Span<byte> destination) 242public static byte[] HashData(ReadOnlySpan<byte> key, Stream source) 265public static byte[] HashData(byte[] key, Stream source) 288public static ValueTask<byte[]> HashDataAsync(ReadOnlyMemory<byte> key, Stream source, CancellationToken cancellationToken = default) 315public static ValueTask<byte[]> HashDataAsync(byte[] key, Stream source, CancellationToken cancellationToken = default) 348Stream source,

System\Security\Cryptography\HMACSHA3_384.cs (6)

216public static int HashData(ReadOnlySpan<byte> key, Stream source, Span<byte> destination) 242public static byte[] HashData(ReadOnlySpan<byte> key, Stream source) 265public static byte[] HashData(byte[] key, Stream source) 288public static ValueTask<byte[]> HashDataAsync(ReadOnlyMemory<byte> key, Stream source, CancellationToken cancellationToken = default) 315public static ValueTask<byte[]> HashDataAsync(byte[] key, Stream source, CancellationToken cancellationToken = default) 348Stream source,

System\Security\Cryptography\HMACSHA3_512.cs (6)

216public static int HashData(ReadOnlySpan<byte> key, Stream source, Span<byte> destination) 242public static byte[] HashData(ReadOnlySpan<byte> key, Stream source) 265public static byte[] HashData(byte[] key, Stream source) 288public static ValueTask<byte[]> HashDataAsync(ReadOnlyMemory<byte> key, Stream source, CancellationToken cancellationToken = default) 315public static ValueTask<byte[]> HashDataAsync(byte[] key, Stream source, CancellationToken cancellationToken = default) 348Stream source,

System\Security\Cryptography\HMACSHA384.cs (6)

195public static int HashData(ReadOnlySpan<byte> key, Stream source, Span<byte> destination) 220public static byte[] HashData(ReadOnlySpan<byte> key, Stream source) 242public static byte[] HashData(byte[] key, Stream source) 265public static ValueTask<byte[]> HashDataAsync(ReadOnlyMemory<byte> key, Stream source, CancellationToken cancellationToken = default) 291public static ValueTask<byte[]> HashDataAsync(byte[] key, Stream source, CancellationToken cancellationToken = default) 324Stream source,

System\Security\Cryptography\HMACSHA512.cs (6)

192public static int HashData(ReadOnlySpan<byte> key, Stream source, Span<byte> destination) 217public static byte[] HashData(ReadOnlySpan<byte> key, Stream source) 239public static byte[] HashData(byte[] key, Stream source) 262public static ValueTask<byte[]> HashDataAsync(ReadOnlyMemory<byte> key, Stream source, CancellationToken cancellationToken = default) 288public static ValueTask<byte[]> HashDataAsync(byte[] key, Stream source, CancellationToken cancellationToken = default) 321Stream source,

System\Security\Cryptography\Kmac128.cs (7)

306Stream source, 343Stream source, 375Stream source, 419Stream source, 466Stream source, 507Stream source, 544private static void CheckStreamCanRead(Stream source)

System\Security\Cryptography\Kmac256.cs (7)

306Stream source, 343Stream source, 375Stream source, 419Stream source, 466Stream source, 507Stream source, 544private static void CheckStreamCanRead(Stream source)

System\Security\Cryptography\KmacXof128.cs (7)

306Stream source, 343Stream source, 375Stream source, 419Stream source, 466Stream source, 507Stream source, 544private static void CheckStreamCanRead(Stream source)

System\Security\Cryptography\KmacXof256.cs (7)

306Stream source, 343Stream source, 375Stream source, 419Stream source, 466Stream source, 507Stream source, 544private static void CheckStreamCanRead(Stream source)

System\Security\Cryptography\LiteHashProvider.cs (11)

13internal static int HashStream(string hashAlgorithmId, Stream source, Span<byte> destination) 19internal static byte[] HashStream(string hashAlgorithmId, int hashSizeInBytes, Stream source) 30Stream source, 45Stream source, 60Stream source, 71Stream source) 83Stream source, 99Stream source, 112private static int ProcessStream<T>(T hash, Stream source, Span<byte> destination) where T : ILiteHash 141Stream source, 173Stream source,

System\Security\Cryptography\LiteHashProvider.Xof.cs (9)

13internal static void XofStream(string hashAlgorithmId, Stream source, Span<byte> destination) 20internal static byte[] XofStream(string hashAlgorithmId, int outputLength, Stream source) 33Stream source, 47Stream source, 59Stream source, 75Stream source, 90Stream source, 108Stream source, 126Stream source,

System\Security\Cryptography\MD5.cs (4)

142public static int HashData(Stream source, Span<byte> destination) 167public static byte[] HashData(Stream source) 193public static ValueTask<byte[]> HashDataAsync(Stream source, CancellationToken cancellationToken = default) 228Stream source,

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

233using (CryptoStream cs = new CryptoStream(Stream.Null, _hash, CryptoStreamMode.Write)) 246using (CryptoStream cs = new CryptoStream(Stream.Null, _hash, CryptoStreamMode.Write))

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

99protected virtual byte[] HashData(Stream data, HashAlgorithmName hashAlgorithm) => 401public virtual byte[] SignData(Stream data, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding) 665public bool VerifyData(Stream data, byte[] signature, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding)

System\Security\Cryptography\RSACryptoServiceProvider.Unix.cs (2)

177public override byte[] SignData(Stream data, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding) 225public byte[] SignData(Stream inputStream, object halg) =>

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

114public override byte[] SignData(Stream data, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding) =>

System\Security\Cryptography\SHA1.cs (4)

136public static int HashData(Stream source, Span<byte> destination) 160public static byte[] HashData(Stream source) 185public static ValueTask<byte[]> HashDataAsync(Stream source, CancellationToken cancellationToken = default) 219Stream source,

System\Security\Cryptography\SHA256.cs (4)

136public static int HashData(Stream source, Span<byte> destination) 160public static byte[] HashData(Stream source) 185public static ValueTask<byte[]> HashDataAsync(Stream source, CancellationToken cancellationToken = default) 219Stream source,

System\Security\Cryptography\SHA3_256.cs (4)

172public static int HashData(Stream source, Span<byte> destination) 200public static byte[] HashData(Stream source) 229public static ValueTask<byte[]> HashDataAsync(Stream source, CancellationToken cancellationToken = default) 267Stream source,

System\Security\Cryptography\SHA3_384.cs (4)

173public static int HashData(Stream source, Span<byte> destination) 201public static byte[] HashData(Stream source) 230public static ValueTask<byte[]> HashDataAsync(Stream source, CancellationToken cancellationToken = default) 268Stream source,

System\Security\Cryptography\SHA3_512.cs (4)

172public static int HashData(Stream source, Span<byte> destination) 200public static byte[] HashData(Stream source) 229public static ValueTask<byte[]> HashDataAsync(Stream source, CancellationToken cancellationToken = default) 267Stream source,

System\Security\Cryptography\SHA384.cs (4)

135public static int HashData(Stream source, Span<byte> destination) 159public static byte[] HashData(Stream source) 184public static ValueTask<byte[]> HashDataAsync(Stream source, CancellationToken cancellationToken = default) 218Stream source,

System\Security\Cryptography\SHA512.cs (4)

135public static int HashData(Stream source, Span<byte> destination) 159public static byte[] HashData(Stream source) 184public static ValueTask<byte[]> HashDataAsync(Stream source, CancellationToken cancellationToken = default) 218Stream source,

System\Security\Cryptography\Shake128.cs (4)

350public static byte[] HashData(Stream source, int outputLength) 379public static void HashData(Stream source, Span<byte> destination) 415public static ValueTask HashDataAsync(Stream source, Memory<byte> destination, CancellationToken cancellationToken = default) 456public static ValueTask<byte[]> HashDataAsync(Stream source, int outputLength, CancellationToken cancellationToken = default)

System\Security\Cryptography\Shake256.cs (4)

350public static byte[] HashData(Stream source, int outputLength) 379public static void HashData(Stream source, Span<byte> destination) 415public static ValueTask HashDataAsync(Stream source, Memory<byte> destination, CancellationToken cancellationToken = default) 456public static ValueTask<byte[]> HashDataAsync(Stream source, int outputLength, CancellationToken cancellationToken = default)

System\Security\Cryptography\Cose\CoseMessage.cs (2)

416Stream? contentStream) 461Stream content,

System\Security\Cryptography\Cose\CoseMultiSignMessage.cs (12)

187public static byte[] SignDetached(Stream detachedContent, CoseSigner signer, CoseHeaderMap? protectedHeaders = null, CoseHeaderMap? unprotectedHeaders = null, ReadOnlySpan<byte> associatedData = default) 203Stream? contentStream, 253Stream detachedContent, 280Stream content, 372Stream? contentStream, 398Stream content, 452Stream? contentStream) 477Stream contentStream, 763public void AddSignatureForDetached(Stream detachedContent, CoseSigner signer, ReadOnlySpan<byte> associatedData = default) 778private void AddSignatureCore(ReadOnlySpan<byte> contentBytes, Stream? contentStream, CoseSigner signer, ReadOnlySpan<byte> associatedData) 839public Task AddSignatureForDetachedAsync(Stream detachedContent, CoseSigner signer, ReadOnlyMemory<byte> associatedData = default, CancellationToken cancellationToken = default) 854private async Task AddSignatureCoreAsync(Stream content, CoseSigner signer, ReadOnlyMemory<byte> associatedData, CancellationToken cancellationToken)

System\Security\Cryptography\Cose\CoseSign1Message.cs (12)

System\Security\Cryptography\Cose\CoseSignature.cs (6)

286/// <seealso cref="VerifyDetachedAsync(AsymmetricAlgorithm, Stream, ReadOnlyMemory{byte}, CancellationToken)"/> 288public bool VerifyDetached(AsymmetricAlgorithm key, Stream detachedContent, ReadOnlySpan<byte> associatedData = default) 354/// <seealso cref="VerifyDetached(AsymmetricAlgorithm, Stream, ReadOnlySpan{byte})"/> 356public Task<bool> VerifyDetachedAsync(AsymmetricAlgorithm key, Stream detachedContent, ReadOnlyMemory<byte> associatedData = default, CancellationToken cancellationToken = default) 385private async Task<bool> VerifyAsyncCore(AsymmetricAlgorithm key, Stream content, ReadOnlyMemory<byte> associatedData, KeyType keyType, CancellationToken cancellationToken) 419private bool VerifyCore(AsymmetricAlgorithm key, ReadOnlySpan<byte> contentBytes, Stream? contentStream, ReadOnlySpan<byte> associatedData, KeyType keyType)

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

15internal CanonicalXml(Stream inputStream, bool includeComments, XmlResolver? resolver, string strBaseUri)

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

200Stream? decInputStream;

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

15internal ExcCanonicalXml(Stream inputStream, bool includeComments, string inclusiveNamespacesPrefixList, XmlResolver resolver, string strBaseUri)

System\Security\Cryptography\Xml\IRelDecryptor.cs (2)

10Stream Decrypt(EncryptionMethod encryptionMethod, KeyInfo keyInfo, Stream toDecrypt);

System\Security\Cryptography\Xml\Reference.cs (5)

41public Reference(Stream stream) 371Stream? hashInputStream = null; 373Stream? inputStream = null; 384hashInputStream = TransformChain.TransformToOctetStream((Stream?)_refTarget, resolver, baseUri); 396hashInputStream = TransformChain.TransformToOctetStream((Stream?)null, resolver!, baseUri);

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

423using (StreamReader reader = new StreamReader((canonicalizationTransform.GetOutput(typeof(Stream)) as Stream)!)) 580internal static Stream? LogReferenceData(Reference reference, Stream? data)

System\Security\Cryptography\Xml\Transform.cs (2)

156return hash.ComputeHash((Stream)GetOutput(typeof(Stream)));

System\Security\Cryptography\Xml\TransformChain.cs (7)

62internal Stream TransformToOctetStream(object? inputObject, XmlResolver? resolver, string? baseUri) 79if (currentInput is Stream) 83Stream currentInputStream = (currentInput as Stream)!; 100if (transform.AcceptsType(typeof(Stream))) 116if (transform.AcceptsType(typeof(Stream))) 135if (currentInput is Stream inputStream)

System\Security\Cryptography\Xml\Utils.cs (3)

180internal static XmlReader PreProcessStreamInput(Stream inputStream, XmlResolver? xmlResolver, string? baseUri) 378internal static long Pump(Stream input, Stream output)

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

18private readonly Type[] _inputTypes = { typeof(Stream), typeof(XmlDocument) }; 139if (obj is Stream) 141LoadStreamInput((Stream)obj); 149private void LoadStreamInput(Stream stream)

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

13private readonly Type[] _inputTypes = { typeof(Stream), typeof(XmlNodeList), typeof(XmlDocument) }; 14private readonly Type[] _outputTypes = { typeof(Stream) }; 43if (obj is Stream) 45LoadStreamInput((Stream)obj); 60private void LoadStreamInput(Stream inputStream) 126if (type != typeof(Stream) && !type.IsSubclassOf(typeof(Stream)))

System\Security\Cryptography\Xml\XmlDsigC14NTransform.cs (6)

11private readonly Type[] _inputTypes = { typeof(Stream), typeof(XmlDocument), typeof(XmlNodeList) }; 12private readonly Type[] _outputTypes = { typeof(Stream) }; 51if (obj is Stream) 53_cXml = new CanonicalXml((Stream)obj, _includeComments, resolver, BaseURI!); 78if (type != typeof(Stream) && !type.IsSubclassOf(typeof(Stream)))

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

11private readonly Type[] _inputTypes = { typeof(Stream), typeof(XmlNodeList), typeof(XmlDocument) }; 61if (obj is Stream) 63LoadStreamInput((Stream)obj); 78private void LoadStreamInput(Stream stream)

System\Security\Cryptography\Xml\XmlDsigExcC14NTransform.cs (6)

11private readonly Type[] _inputTypes = { typeof(Stream), typeof(XmlDocument), typeof(XmlNodeList) }; 12private readonly Type[] _outputTypes = { typeof(Stream) }; 78if (obj is Stream) 80_excCanonicalXml = new ExcCanonicalXml((Stream)obj, _includeComments, _inclusiveNamespacesPrefixList!, resolver, BaseURI!); 115if (type != typeof(Stream) && !type.IsSubclassOf(typeof(Stream)))

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

14private readonly Type[] _inputTypes = { typeof(Stream), typeof(XmlNodeList), typeof(XmlDocument) }; 120if (obj is Stream) 122LoadStreamInput((Stream)obj); 134private void LoadStreamInput(Stream stream)

System\Security\Cryptography\Xml\XmlDsigXsltTransform.cs (8)

15private readonly Type[] _inputTypes = { typeof(Stream), typeof(XmlDocument), typeof(XmlNodeList) }; 16private readonly Type[] _outputTypes = { typeof(Stream) }; 19private Stream? _inputStream; 86if (obj is Stream) 88_inputStream = (Stream)obj; 145if (type != typeof(Stream) && !type.IsSubclassOf(typeof(Stream))) 147return (Stream)GetOutput();

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

75Stream? decryptedContent = null;

System\ServiceModel\Channels\Connection.cs (2)

283public StreamConnection(Stream stream, ConnectionStream innerStream) 333public Stream Stream { get; }

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

440Stream upgradedStream = await upgradeInitiator.InitiateUpgradeAsync(connectionStream);

System\ServiceModel\Channels\SingletonConnectionReader.cs (4)

26private Stream _inputStream; 176Stream connectionStream = new SingletonInputConnectionStream(this, singletonConnection, _transportSettings); 584Stream connectionStream = new StreamingOutputConnectionStream(connection, settings); 585Stream writeTimeoutStream = new TimeoutStream(connectionStream, timeoutHelper.RemainingTime());

System\ServiceModel\Channels\SslStreamSecurityUpgradeProvider.cs (2)

349protected override async Task<(Stream upgradedStream, SecurityMessageProperty remoteSecurity)> OnInitiateUpgradeAsync(Stream stream)

System\ServiceModel\Channels\StreamSecurityUpgradeInitiatorBase.cs (5)

45public override async Task<Stream> InitiateUpgradeAsync(Stream stream) 57Stream result; 75protected abstract Task<(Stream upgradedStream, SecurityMessageProperty remoteSecurity)> OnInitiateUpgradeAsync(Stream stream);

System\ServiceModel\Channels\StreamUpgradeInitiator.cs (2)

13public abstract Task<Stream> InitiateUpgradeAsync(Stream stream);

System\ServiceModel\Channels\WindowsStreamSecurityUpgradeProvider.cs (3)

164protected override async Task<(Stream upgradedStream, SecurityMessageProperty remoteSecurity)> OnInitiateUpgradeAsync(Stream stream) 202Stream stream,

netstandard.cs (4)

1589public virtual void WriteMessage(System.IO.Stream stream) { } 1601public System.ServiceModel.Channels.Message ReadMessage(System.IO.Stream stream, int maxSizeOfHeaders) { return default; } 1602public abstract System.ServiceModel.Channels.Message ReadMessage(System.IO.Stream stream, int maxSizeOfHeaders, string contentType); 1606public abstract void WriteMessage(System.ServiceModel.Channels.Message message, System.IO.Stream stream);

System\ServiceModel\Channels\UnixPosixIdentitySecurityUpgradeProvider.cs (2)

101public override Task<Stream> InitiateUpgradeAsync(Stream stream)

artifacts\obj\System.Speech\Debug\net10.0\System.Speech.notsupported.cs (15)

System\Text\BaseCodePageEncoding.cs (6)

103private static unsafe void ReadCodePageDataFileHeader(Stream stream, byte[] codePageDataFileHeader) 141private static unsafe void ReadCodePageIndex(Stream stream, byte[] codePageIndex) 187private static unsafe void ReadCodePageHeader(Stream stream, byte[] codePageHeader) 217protected static Stream s_codePagesEncodingDataStream = GetEncodingDataStream(CODE_PAGE_DATA_FILE_NAME); 228internal static Stream GetEncodingDataStream(string tableName) 235Stream? stream = typeof(CodePagesEncodingProvider).Assembly.GetManifestResourceStream(tableName);

System\Text\BaseCodePageEncoding.netcoreapp.cs (1)

14private static unsafe void ReadCodePageIndex(Stream stream, Span<byte> codePageIndex)

src\libraries\Common\src\System\Text\Json\PooledByteBufferWriter.cs (3)

18private readonly Stream? _stream; 25public PooledByteBufferWriter(int initialCapacity, Stream stream) : this(initialCapacity) 71internal void WriteToStream(Stream destination) => destination.Write(_buffer.ActiveSpan);

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

104/// Parse a <see cref="Stream"/> as UTF-8 encoded data representing a single JSON value into a 118public static JsonDocument Parse(Stream utf8Json, JsonDocumentOptions options = default) 149internal static JsonDocument ParseValue(Stream utf8Json, JsonDocumentOptions options) 181/// Parse a <see cref="Stream"/> as UTF-8 encoded data representing a single JSON value into a 197Stream utf8Json, 210Stream utf8Json, 230Stream utf8Json, 761private static ArraySegment<byte> ReadToEnd(Stream stream) 842Stream stream,

System\Text\Json\Document\JsonElement.Parse.cs (1)

56internal static JsonElement ParseValue(Stream utf8Json, JsonDocumentOptions options)

System\Text\Json\Nodes\JsonNode.Parse.cs (4)

106/// Parse a <see cref="Stream"/> as UTF-8 encoded data representing a single JSON value into a 119Stream utf8Json, 133/// Parse a <see cref="Stream"/> as UTF-8 encoded data representing a single JSON value into a 147Stream utf8Json,

System\Text\Json\Serialization\JsonSerializer.Read.Stream.cs (16)

45Stream utf8Json, 81Stream utf8Json, 119Stream utf8Json, 160Stream utf8Json, 197Stream utf8Json, 232Stream utf8Json, 266Stream utf8Json, 297Stream utf8Json, 341Stream utf8Json, 388Stream utf8Json, 424Stream utf8Json, 453Stream utf8Json, 480Stream utf8Json, 507Stream utf8Json, 527Stream utf8Json, 549Stream utf8Json,

System\Text\Json\Serialization\JsonSerializer.Write.Stream.cs (30)

System\Text\Json\Serialization\JsonSerializer.Write.String.cs (5)

26/// and <see cref="SerializeAsync{TValue}(IO.Stream, TValue, JsonSerializerOptions?, Threading.CancellationToken)"/>. 55/// and <see cref="SerializeAsync(IO.Stream, object?, Type, JsonSerializerOptions?, Threading.CancellationToken)"/>. 81/// and <see cref="SerializeAsync{TValue}(IO.Stream, TValue, JsonTypeInfo{TValue}, Threading.CancellationToken)"/>. 108/// and <see cref="SerializeAsync(IO.Stream, object?, JsonTypeInfo, Threading.CancellationToken)"/>. 141/// and <see cref="SerializeAsync(IO.Stream, object?, Type, JsonSerializerContext, Threading.CancellationToken)"/>.

System\Text\Json\Serialization\Metadata\JsonTypeInfo.cs (4)

1055internal abstract Task SerializeAsObjectAsync(Stream utf8Json, object? rootValue, CancellationToken cancellationToken); 1057internal abstract void SerializeAsObject(Stream utf8Json, object? rootValue); 1061internal abstract ValueTask<object?> DeserializeAsObjectAsync(Stream utf8Json, CancellationToken cancellationToken); 1062internal abstract object? DeserializeAsObject(Stream utf8Json);

System\Text\Json\Serialization\Metadata\JsonTypeInfoOfT.ReadHelper.cs (4)

25internal async ValueTask<T?> DeserializeAsync(Stream utf8Json, CancellationToken cancellationToken) 58internal T? Deserialize(Stream utf8Json) 102internal sealed override async ValueTask<object?> DeserializeAsObjectAsync(Stream utf8Json, CancellationToken cancellationToken) 108internal sealed override object? DeserializeAsObject(Stream utf8Json)

System\Text\Json\Serialization\Metadata\JsonTypeInfoOfT.WriteHelpers.cs (4)

62internal Task SerializeAsync(Stream utf8Json, 250Stream utf8Json, 337internal sealed override Task SerializeAsObjectAsync(Stream utf8Json, object? rootValue, CancellationToken cancellationToken) 343internal sealed override void SerializeAsObject(Stream utf8Json, object? rootValue)

System\Text\Json\Serialization\ReadBufferState.cs (2)

62Stream utf8Json, 94public void ReadFromStream(Stream utf8Json)

System\Text\Json\Writer\Utf8JsonWriter.cs (10)

39private Stream? _stream; 231/// <param name="utf8Json">An instance of <see cref="Stream" /> used as a destination for writing JSON text into.</param> 236/// Thrown when the instance of <see cref="Stream" /> that is passed in is null. 238public Utf8JsonWriter(Stream utf8Json, JsonWriterOptions options = default) 274/// and the original output as the destination (either <see cref="IBufferWriter{Byte}" /> or <see cref="Stream" />). 288/// Resets the <see cref="Utf8JsonWriter"/> internal state so that it can be re-used with the new instance of <see cref="Stream" />. 290/// <param name="utf8Json">An instance of <see cref="Stream" /> used as a destination for writing JSON text into.</param> 293/// but now write to the passed in <see cref="Stream" /> as the new destination. 296/// Thrown when the instance of <see cref="Stream" /> that is passed in is null. 301public void Reset(Stream utf8Json)

artifacts\obj\System.Windows.Extensions\Debug\net10.0\System.Windows.Extensions.notsupported.cs (2)

13public SoundPlayer(System.IO.Stream? stream) { throw new System.PlatformNotSupportedException(System.SR.PlatformNotSupported_System_Windows_Extensions); } 23public System.IO.Stream? Stream { get { throw new System.PlatformNotSupportedException(System.SR.PlatformNotSupported_System_Windows_Extensions); } set { throw new System.PlatformNotSupportedException(System.SR.PlatformNotSupported_System_Windows_Extensions); } }

System\Drawing\Design\UITypeEditor.cs (1)

44[typeof(Stream)] = $"System.ComponentModel.Design.BinaryEditor, {AssemblyRef.SystemDesign}",

System\Resources\ResXResourceReader.cs (6)

20private Stream? _stream; 82public ResXResourceReader(Stream stream) : this(stream, typeResolver: null, aliasResolver: null) 86public ResXResourceReader(Stream stream, ITypeResolutionService typeResolver) 91internal ResXResourceReader(Stream stream, ITypeResolutionService? typeResolver, IAliasResolver? aliasResolver) 98public ResXResourceReader(Stream stream, AssemblyName[] assemblyNames) 103internal ResXResourceReader(Stream stream, AssemblyName[] assemblyNames, IAliasResolver? aliasResolver)

System\Resources\ResXResourceSet.cs (1)

21public ResXResourceSet(Stream stream) : base(new ResXResourceReader(stream))

System\Resources\ResXResourceWriter.cs (3)

89private Stream? _stream; 117public ResXResourceWriter(Stream stream) => _stream = stream; 119public ResXResourceWriter(Stream stream, Func<Type?, string> typeNameConverter)

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

23internal PropertyBagStream(Stream stream) 104internal void Save(Stream stream)

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

69public State(Stream ms, int storageType, bool manualUpdate, string? licKey) 221private void InitializeFromStream(Stream dataStream, bool initializeBufferOnly = false)

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

932using Stream? stream = module.Assembly.GetManifestResourceStream(

System\Windows\Forms\BinaryFormat\WinFormsBinaryFormatWriter.cs (4)

19public static void WriteBitmap(Stream stream, Bitmap bitmap) 38public static void WriteImageListStreamer(Stream stream, ImageListStreamer streamer) 57public static bool TryWriteObject(Stream stream, object value) 63static bool Write(Stream stream, object value)

System\Windows\Forms\Controls\ImageList\ImageListStreamer.cs (2)

101internal void GetObjectData(Stream stream) 111private bool WriteImageList(Stream stream)

System\Windows\Forms\Controls\PictureBox\PictureBox.cs (5)

97private Stream? _uriImageStream; 663Stream responseStream = webResponse.GetResponseStream(); 689Stream responseStream = (Stream)result.AsyncState!; 726Stream rs = responseStream;

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

68private Stream? _editStream; 2319public void LoadFile(Stream data, RichTextBoxStreamType fileType) 2645public void SaveFile(Stream data, RichTextBoxStreamType fileType) 2840private void StreamIn(Stream data, uint flags) 2984private void StreamOut(Stream data, uint flags, bool includeCrLfs)

System\Windows\Forms\Controls\WebBrowser\WebBrowser.cs (3)

32private Stream? _documentStreamToSetOnLoad; 259public unsafe Stream? DocumentStream 311using Stream? stream = DocumentStream;

System\Windows\Forms\Dialogs\CommonDialogs\OpenFileDialog.cs (1)

95public Stream OpenFile()

System\Windows\Forms\Dialogs\CommonDialogs\SaveFileDialog.cs (1)

75public Stream OpenFile()

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

8Stream OpenFileFromSource(string relativePath);

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

92public Cursor(Stream stream)

System\Windows\Forms\Nrbf\WinFormsNrbfSerializer.cs (1)

55public static bool TryWriteObject(Stream stream, object value) =>

System\Windows\Forms\OLE\Clipboard.cs (3)

151public static Stream? GetAudioStream() => GetTypedDataIfAvailable<Stream>(DataFormatNames.WaveAudio); 403public static void SetAudio(Stream audioStream) =>

System\Windows\Forms\OLE\DataObject.cs (3)

245public virtual Stream? GetAudioStream() => GetData(DataFormats.WaveAudio, autoConvert: false) as Stream; 272public virtual void SetAudio(Stream audioStream) =>

System\ComponentModel\Design\BinaryEditor.cs (3)

40/// of this supports byte[] and <see cref="Stream"/> objects. 44if (value is Stream stream) 76if (value is Stream stream)

System\ComponentModel\Design\Serialization\CodeDomComponentSerializationService.CodeDomSerializationStore.cs (2)

313/// The <see cref="Save(Stream)"/> method is not supported on .NET because this class is not binary serializable. 318public override void Save(Stream stream) => throw new PlatformNotSupportedException();

System\ComponentModel\Design\Serialization\CodeDomComponentSerializationService.cs (3)

16/// as the <see cref="LoadStore(Stream)"/> and <see cref="SerializationStore.Save(Stream)"/> 52public override SerializationStore LoadStore(Stream stream) => throw new PlatformNotSupportedException();

System\Drawing\BitmapSelector.cs (5)

54private static Stream? GetResourceStreamHelper(Assembly assembly, Type type, string name) 56Stream? stream = null; 107internal static Stream? GetResourceStream(Type type, string originalName) 119Stream? stream = GetResourceStreamHelper(assembly, type, newName); 144Stream? stream = GetResourceStreamHelper(satellite, type, originalName);

System\Drawing\Design\BitmapEditor.cs (1)

19protected override Image LoadFromStream(Stream stream) => new Bitmap(stream);

System\Drawing\Design\ColorEditor.CustomColorDialog.cs (1)

22using Stream stream = s_assembly.GetManifestResourceStream(s_resourceName)!;

System\Drawing\Design\IconEditor.cs (1)

107protected virtual Icon LoadFromStream(Stream stream) => new(stream);

System\Drawing\Design\ImageEditor.cs (1)

160protected virtual Image LoadFromStream(Stream stream)

System\Drawing\Design\MetafileEditor.cs (1)

18protected override Image LoadFromStream(Stream stream) => new Metafile(stream);

System\Windows\Forms\Design\ImageListImage.cs (1)

50public static ImageListImage ImageListImageFromStream(Stream stream, bool imageIsIcon)

System\Windows\Forms\Design\ImageListImageEditor.cs (1)

99private static ImageListImage LoadImageFromStream(Stream stream, bool imageIsIcon)

EnsureEditorsTests.cs (1)

45[InlineData(typeof(Stream), typeof(BinaryEditor))]

System\Drawing\Design\BitmapEditorTests.cs (2)

88using Stream stream = File.OpenRead("Resources/telescope_01.wmf"); 110public new Image LoadFromStream(Stream stream) => base.LoadFromStream(stream);

System\Drawing\Design\ImageEditorTests.cs (2)

145using Stream stream = File.OpenRead("Resources/telescope_01.wmf"); 216public new Image LoadFromStream(Stream stream) => base.LoadFromStream(stream);

System\Drawing\Design\MetafileEditorTests.cs (2)

67using Stream stream = File.OpenRead("Resources/telescope_01.wmf"); 85public new Image LoadFromStream(Stream stream) => base.LoadFromStream(stream);

System\Resources\Tools\CodeDomCompileHelper.cs (3)

32private static Stream CreateAssemblyImage(string source, string assemblyName, string resourceName, Stream resource) 61Stream resource = null)

System\Windows\Forms\Design\EmbeddedResourceTests.cs (2)

92using Stream stream = _assembly.GetManifestResourceStream(resourceName); 103using Stream stream = _assembly.GetManifestResourceStream(resourceName);

System\Windows\Forms\Design\ImageListImageEditorTests.cs (1)

15var editor_LoadImageFromStream = editor.TestAccessor().CreateDelegate<Func<Stream, bool, ImageListImage>>("LoadImageFromStream");

System\Windows\Forms\Internals\ScaleHelper.cs (2)

346internal static Bitmap GetIconResourceAsBestMatchBitmap(Stream resourceStream, Size size) 359using Stream stream = type.Module.Assembly.GetManifestResourceStream(type, resource)

System\Windows\Forms\Internals\ThemingScope.cs (1)

75public static unsafe bool CreateActivationContext(Stream manifest)

Windows\Win32\PInvoke.ImageList.cs (2)

121public static BOOL Write<T>(T himl, Stream pstm) where T : IHandle<HIMAGELIST> 133Stream pstm) where T : IHandle<HIMAGELIST>

System\Windows\Forms\BinaryFormat\BinaryFormatTestExtensions.cs (2)

18using Stream stream = source.Serialize(); 25public static Stream Serialize(this object source)

SerializableTypesTests.cs (1)

62Stream bufferStream = managedStream.GetDataStream();

System\Resources\ResXResourceReaderTests.cs (1)

76using Stream resxStream = new MemoryStream(resxBytes);

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

145using Stream stream = typeof(Application).Module.Assembly.GetManifestResourceStream(

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

104Stream? result = Clipboard.GetAudioStream(); 224Action action = () => Clipboard.SetAudio((Stream)null!);

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

92Assert.Throws<ArgumentNullException>("stream", () => new Cursor((Stream)null));

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

210public static TheoryData<object, Stream> GetAudioStream_TheoryData() 212TheoryData<object, Stream> theoryData = new() 225public void DataObject_GetAudioStream_InvokeWithData_ReturnsExpected(object result, Stream expected) 234public void DataObject_GetAudioStream_InvokeMocked_ReturnsExpected(object result, Stream expected) 1154Action action = () => dataObject.SetAudio((Stream)null);

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

204using Stream stream = _assembly.GetManifestResourceStream(resourceName); 233using Stream stream = _assembly.GetManifestResourceStream(resourceName);

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

8760Assert.Throws<ArgumentNullException>("data", () => control.LoadFile((Stream)null, RichTextBoxStreamType.RichText)); 9677control.SaveFile((Stream)null, RichTextBoxStreamType.RichText); 9688control.SaveFile((Stream)null, RichTextBoxStreamType.RichText); 9704control.SaveFile((Stream)null, RichTextBoxStreamType.RichText); 9723control.SaveFile((Stream)null, RichTextBoxStreamType.RichText);

Infra\ScreenRecordService.cs (13)

System\Xaml\InfosetObjects\XamlXmlReader.cs (5)

93public XamlXmlReader(Stream stream) 99public XamlXmlReader(Stream stream, XamlXmlReaderSettings settings) 105public XamlXmlReader(Stream stream, XamlSchemaContext schemaContext) 113public XamlXmlReader(Stream stream, XamlSchemaContext schemaContext, XamlXmlReaderSettings settings) 121private XmlReader CreateXmlReader(Stream stream, XamlXmlReaderSettings settings)

System\Xaml\XamlServices.cs (2)

44public static object Load(Stream stream) 157public static void Save(Stream stream, object instance)

System\Xaml\XamlXmlWriter.cs (2)

46public XamlXmlWriter(Stream stream, XamlSchemaContext schemaContext) 51public XamlXmlWriter(Stream stream, XamlSchemaContext schemaContext, XamlXmlWriterSettings settings)

System\Xaml\XamlServicesTests.cs (2)

28Assert.Throws<ArgumentNullException>("stream", () => XamlServices.Load((Stream)null!)); 78Assert.Throws<ArgumentNullException>("stream", () => XamlServices.Save((Stream)null!, 1));

BaselineTest.cs (1)

35using (var stream = typeof(BaselineTest).Assembly.GetManifestResourceStream(BaselineDefinitionFileResourceName))

ServiceInterfaces.cs (6)

56Stream GetStreamFromString(string data); 59string GetStringFromStream(Stream stream); 62Stream EchoStream(Stream stream); 65Task<Stream> EchoStreamAsync(Stream stream);

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

122public static async Task<BuildRequest> ReadAsync(Stream inStream, CancellationToken cancellationToken) 158public async Task WriteAsync(Stream outStream, CancellationToken cancellationToken = default(CancellationToken)) 280public async Task WriteAsync(Stream outStream, 318public static async Task<BuildResponse> ReadAsync(Stream stream, CancellationToken cancellationToken = default(CancellationToken)) 607Stream stream,

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

103private Stream? _loggingStream;

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

122public static async Task<BuildRequest> ReadAsync(Stream inStream, CancellationToken cancellationToken) 158public async Task WriteAsync(Stream outStream, CancellationToken cancellationToken = default(CancellationToken)) 280public async Task WriteAsync(Stream outStream, 318public static async Task<BuildResponse> ReadAsync(Stream stream, CancellationToken cancellationToken = default(CancellationToken)) 607Stream stream,

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

103private Stream? _loggingStream;

src\Compilers\Server\VBCSCompiler\MetadataCache.cs (1)

26var fileStream = FileUtilities.OpenRead(path);

System\IO\Packaging\EncryptedPackageEnvelopeTests.cs (1)

13Assert.Throws<ArgumentNullException>("envelopeStream", () => EncryptedPackageEnvelope.Open((Stream)null!));

Program.cs (1)

75using (var resources = compilation.CreateDefaultWin32Resources(true, true, null, null))

Program.cs (1)

48using (var certificateStream = certificateFileInfo.CreateReadStream())

common\AssemblyResolution\Microsoft.Extensions.DependencyModel\DependencyContextJsonReader.cs (1)

18public DependencyContext Read(Stream stream)

common\AssemblyResolution\Microsoft.Extensions.DependencyModel\DependencyContextLoader.cs (4)

48private static Stream GetResourceStream(Assembly assembly, string name) 98using (var stream = _fileSystem.File.OpenRead(location)) 108using (var stream = GetResourceStream(assembly, assembly.GetName().Name + DepsJsonExtension)) 119using (var stream = _fileSystem.File.OpenRead(depsJsonFile))

common\AssemblyResolution\Microsoft.Extensions.DependencyModel\FileWrapper.cs (2)

21public Stream OpenRead(string path) 26public Stream OpenFile(

common\AssemblyResolution\Microsoft.Extensions.DependencyModel\IDependencyContextReader.cs (1)

11DependencyContext Read(Stream stream);

common\AssemblyResolution\Microsoft.Extensions.DependencyModel\IFile.cs (2)

14Stream OpenRead(string path); 16Stream OpenFile(

Utility\TransformFactory.cs (1)

75using (var xsltStream = typeof(TransformFactory).GetTypeInfo().Assembly.GetManifestResourceStream($"Xunit.ConsoleClient.{resourceName}"))