File

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

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

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

Microsoft.ML.SamplesUtils (1)

SamplesDatasetUtils.cs (1)

193if (File.Exists(dataFile))

Microsoft.ML.Sweeper (4)

ConfigRunner.cs (4)

84if (!File.Exists(Exe) && !File.Exists(Exe + ".exe")) 211if (File.Exists(errorFile) && new FileInfo(errorFile).Length == 0) 213File.Delete(errorFile);

Microsoft.ML.TensorFlow (2)

TensorflowUtils.cs (2)

275FileAttributes attr = File.GetAttributes(modelPath); 408env.CheckUserArg(File.Exists(modelPath), nameof(modelPath));

Microsoft.ML.TensorFlow.Tests (13)

TensorflowTests.cs (13)

1432using (var file = File.OpenRead("model.zip")) 1449if (Directory.Exists(workspacePath) && File.Exists(Path.Combine(workspacePath, trainSetBottleneckCachedValuesFileName)) 1450&& File.Exists(Path.Combine(workspacePath, validationSetBottleneckCachedValuesFileName))) 1535using (var file = File.OpenRead("model.zip")) 1694using (var file = File.OpenRead("model.zip")) 1750Assert.True(File.Exists(Path.Combine(options.WorkspacePath, options.TrainSetBottleneckCachedValuesFileName))); 1751Assert.True(File.Exists(Path.Combine(options.WorkspacePath, options.ValidationSetBottleneckCachedValuesFileName))); 1752Assert.True(File.Exists(Path.Combine(Path.GetTempPath(), "MLNET", ImageClassificationTrainer.ModelFileName[options.Arch]))); 1825using (var file = File.OpenRead("model.zip")) 1896using (var file = File.OpenRead("model.zip")) 1985if (File.Exists(relativeFilePath)) 2012if (File.Exists(Path.Combine(destFolder, flag))) 2016File.Create(Path.Combine(destFolder, flag));

Microsoft.ML.TestFramework (43)

BaseTestBaseline.cs (10)

289if (File.Exists(baselinePath)) 336File.Delete(rawPath); 337File.Move(path, rawPath); 340using (TextWriter dst = File.CreateText(path)) 433File.Delete(outPath + RawSuffix); 940if (!File.Exists(outPath)) 954if (!File.Exists(basePath)) 1002return Utils.OpenWriter(File.Open(path, append ? FileMode.Append : FileMode.OpenOrCreate), encoding, bufferSize, false); 1014return new StreamReader(File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read)); 1045File.WriteAllText(path,

BaseTestPredictorsMaml.cs (2)

264File.Delete(consOutPath2.Path); 288File.Delete(outPath);

DataPipe\TestDataPipe.cs (19)

DataPipe\TestDataPipeBase.cs (4)

87using (var fs = File.OpenRead(modelPath)) 395using (var stream = File.Create(pathData)) 541using (var stream = File.Create(pathData)) 592using (var stream = File.Create(pathData))

TestCommandBase.cs (8)

353File.Delete(testOutPath + RawSuffix); 756File.WriteAllLines(path.Path, new string[] { 772File.WriteAllLines(path2.Path, new string[] { 1305File.WriteAllLines(dataPath.Path, new string[] { 2238File.WriteAllLines(path.Path, new string[] { 2260File.WriteAllLines(path.Path, new string[] { 2270File.WriteAllLines(path.Path, new string[] { 2278File.WriteAllLines(path.Path, new string[] { "1 aurora:2 :3" });

Microsoft.ML.TestFrameworkCommon (3)

TestCommon.cs (2)

47File.Delete(path); 54File.Delete(path);

Utility\LibraryLoader.cs (1)

99if (!Path.IsPathRooted(loadTarget) || File.Exists(loadTarget))

Microsoft.ML.Tests (77)

BinaryLoaderSaverTests.cs (1)

29using (var fs = File.Create(outputPath))

FeatureContributionTests.cs (1)

244using (var fs = File.Create(outputPath))

OnnxConversionTest.cs (13)

450var fileText = File.ReadAllText(onnxTextPath); 452File.WriteAllText(onnxTextPath, fileText); 703File.WriteAllLines(jsonPath, new[] { inputGraph }); 735File.WriteAllLines(jsonPath, new[] { inputGraph }); 747using (var modelStream = File.OpenRead(onnxPath)) 756File.Delete(modelPath); 757File.Delete(onnxPath); 758File.Delete(onnxJsonPath); 1026File.WriteAllLines(dataFile, 1729using (var stream = File.Create(onnxModelPath)) 1735using (var modelStream = File.OpenRead(onnxModelPath)) 2288var fileText = File.ReadAllText(textFormatPath); 2291File.WriteAllText(textFormatPath, fileText);

Scenarios\Api\TestApi.cs (2)

166using (var fs = File.Create(GetOutputPath(OutputRelativePath, "lambda-output.tsv"))) 271var data = File.ReadAllLines(dataFile)

SvmLightTests.cs (5)

37File.WriteAllLines(path, data); 49using (var stream = File.Create(savingPath)) 174using (var stream = File.Create(outputPath)) 197using (var stream = File.Create(outputPath)) 220using (var stream = File.Create(outputPath))

TermEstimatorTests.cs (1)

86using (var fs = File.Create(outputPath))

TextLoaderTests.cs (7)

34File.WriteAllLines(pathData, new string[] { 94File.WriteAllLines(pathData, new string[] { 119File.WriteAllLines(pathData, new string[] { 817using (FileStream modelfs = File.OpenRead(textLoaderModelPath)) 837using (FileStream modelfs = File.OpenRead(textLoaderModelPath)) 1306using (var fs = File.Create(savedPath)) 1384File.WriteAllText(filePath, badInputCsv);

TrainerEstimators\CalibratorEstimators.cs (1)

258using (var fs = File.OpenRead(modelPath))

TrainerEstimators\LbfgsTests.cs (4)

125using (var fs = File.OpenRead(modelAndSchemaPath)) 146using (FileStream fs = File.OpenRead(dropModelPath)) 220using (var fs = File.OpenRead(modelAndSchemaPath)) 237using (FileStream fs = File.OpenRead(dropModelPath))

TrainerEstimators\MatrixFactorizationTests.cs (1)

541using (var fs = File.OpenRead(modelPath))

Transformers\CategoricalHashTests.cs (2)

71using (var fs = File.Create(outputPath)) 104using (var fs = File.Create(outputPath))

Transformers\CategoricalTests.cs (2)

90using (var fs = File.Create(outputPath)) 176using (var fs = File.Create(outputPath))

Transformers\ConcatTests.cs (2)

90using (var fs = File.Create(outputPath)) 154using (var fs = File.Create(outputPath))

Transformers\ConvertTests.cs (1)

395using (var fs = File.OpenRead(modelPath))

Transformers\FeatureSelectionTests.cs (4)

53using (var fs = File.Create(outputPath)) 88using (var fs = File.Create(outputPath)) 130using (var fs = File.Create(outputPath)) 190using (var fs = File.Create(outputPath))

Transformers\HashTests.cs (1)

344using (var fs = File.Create(outputPath))

Transformers\KeyToValueTests.cs (1)

56using (var fs = File.Create(outputPath))

Transformers\NAIndicatorTests.cs (1)

118using (var fs = File.Create(outputPath))

Transformers\NAReplaceTests.cs (1)

145using (var fs = File.Create(outputPath))

Transformers\NormalizerTests.cs (7)

88using (var fs = File.Create(outputPath)) 678using (var fs = File.Create(outputPath)) 712using (var fs = File.Create(outputPath)) 775using (var fs = File.Create(outputPath)) 835using (var fs = File.Create(outputPath)) 876using (FileStream fs = File.OpenRead(chooseModelPath)) 1012using (var fs = File.Create(outputPath))

Transformers\PcaTests.cs (1)

63using (var fs = File.Create(outputPath))

Transformers\RffTests.cs (1)

78using (var fs = File.Create(outputPath))

Transformers\SelectColumnsTests.cs (4)

221using (FileStream fs = File.OpenRead(dropModelPath)) 249using (FileStream fs = File.OpenRead(dropModelPath)) 277using (FileStream fs = File.OpenRead(dropModelPath)) 305using (FileStream fs = File.OpenRead(chooseModelPath))

Transformers\TextFeaturizerTests.cs (8)

447using (var fs = File.Create(outputPath)) 478using (var fs = File.Create(outputPath)) 502using (var fs = File.Create(outputPath)) 546using (var fs = File.Create(outputPath)) 608using (var fs = File.Create(outputPath)) 643using (var fs = File.Create(outputPath)) 660using (FileStream fs = File.OpenRead(dropModelPath)) 702using (var fs = File.Create(outputPath))

Transformers\TextNormalizer.cs (1)

64using (var fs = File.Create(outputPath))

Transformers\ValueMappingTests.cs (2)

717using (FileStream fs = File.OpenRead(termLookupModelPath)) 734using (FileStream fs = File.OpenRead(termLookupModelPath))

Transformers\WordEmbeddingsTests.cs (2)

54using (var fs = File.Create(outputPath)) 97using (var fs = File.Create(outputPath))

Microsoft.ML.TimeSeries (1)

PredictionEngine.cs (1)

90using (var file = File.Create(modelPath))

Microsoft.ML.TimeSeries.Tests (5)

TimeSeries.cs (1)

81File.WriteAllLines(pathData, Enumerable.Repeat("0", 50));

TimeSeriesDirectApi.cs (4)

251using (var file = File.OpenRead(modelPath)) 271using (var file = File.OpenRead(modelPath + 1)) 339using (var file = File.OpenRead(modelPath)) 494using (var file = File.OpenRead("model.zip"))

Microsoft.ML.Tokenizers (17)

Model\BertTokenizer.cs (2)

665string.IsNullOrEmpty(vocabFilePath) ? throw new ArgumentNullException(nameof(vocabFilePath)) : File.OpenRead(vocabFilePath), 722Stream stream = string.IsNullOrEmpty(vocabFilePath) ? throw new ArgumentNullException(nameof(vocabFilePath)) : File.OpenRead(vocabFilePath);

Model\BpeOptions.cs (4)

44if (!File.Exists(vocabFile)) 49using Stream vocabStream = File.OpenRead(vocabFile); 61if (!File.Exists(mergesFile)) 66using Stream mergesStream = File.OpenRead(mergesFile);

Model\BPETokenizer.cs (2)

127using Stream vocabStream = File.OpenRead(vocabFile); 128using Stream? mergesStream = mergesFile is null ? null : File.OpenRead(mergesFile);

Model\CodeGenTokenizer.cs (2)

67this(vocabularyPath is null ? throw new ArgumentNullException(nameof(vocabularyPath)) : File.OpenRead(vocabularyPath), 68mergePath is null ? throw new ArgumentNullException(nameof(mergePath)) : File.OpenRead(mergePath),

Model\EnglishRobertaTokenizer.cs (3)

119this(vocabularyPath is null ? throw new ArgumentNullException(nameof(vocabularyPath)) : File.OpenRead(vocabularyPath), 120mergePath is null ? throw new ArgumentNullException(nameof(mergePath)) : File.OpenRead(mergePath), 121highestOccurrenceMappingPath is null ? throw new ArgumentNullException(nameof(highestOccurrenceMappingPath)) : File.OpenRead(highestOccurrenceMappingPath),

Model\TiktokenTokenizer.cs (2)

47this(string.IsNullOrEmpty(vocabFilePath) ? throw new ArgumentNullException(nameof(vocabFilePath)) : File.OpenRead(vocabFilePath), preTokenizer, specialTokens, normalizer, cacheSize, disposeStream: true) 1428using Stream vocabStream = File.OpenRead(vocabFilePath);

Model\WordPieceTokenizer.cs (2)

134Create(string.IsNullOrEmpty(vocabFilePath) ? throw new ArgumentNullException(nameof(vocabFilePath)) : File.OpenRead(vocabFilePath), options, disposeStream: true); 192string.IsNullOrEmpty(vocabFilePath) ? throw new ArgumentNullException(nameof(vocabFilePath)) : File.OpenRead(vocabFilePath),

Microsoft.ML.Tokenizers.Data.Tests (3)

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

41if (File.Exists(file)) 45File.Delete(file); 58using Stream fileStream = File.Create(fileName);

Microsoft.ML.Tokenizers.Tests (59)

BertTokenizerTests.cs (16)

41using Stream vocabStream = File.OpenRead(vocabFile); 98File.Delete(vocabFile); 112using Stream vocabStream = File.OpenRead(vocabFile); 169File.Delete(vocabFile); 183using Stream vocabStream = File.OpenRead(vocabFile); 219File.Delete(vocabFile); 234using Stream vocabStream = File.OpenRead(vocabFile); 296File.Delete(vocabFile); 309using Stream vocabStream = File.OpenRead(vocabFile); 348File.Delete(vocabFile); 362using Stream vocabStream = File.OpenRead(vocabFile); 448File.Delete(vocabFile); 462using Stream vocabStream = File.OpenRead(vocabFile); 541File.Delete(vocabFile); 555using Stream vocabStream = File.OpenRead(vocabFile); 599File.Delete(vocabFile);

BpeTests.cs (10)

366using Stream vocabStream = File.OpenRead(Path.Combine(@"Gpt-2", "vocab.json")); 367using Stream mergesStream = File.OpenRead(Path.Combine(@"Gpt-2", "merges.txt")); 386using Stream vocabStream = File.OpenRead(vocabFile); 387using Stream mergesStream = File.OpenRead(mergesFile); 399string jsonString = File.ReadAllText(vocabFile); 405Merges = File.ReadAllLines(mergesFile).Skip(1).ToArray() // Skip the first line which is the header "#version". 546using Stream vocabStream = File.OpenRead(Path.Combine(@"Gpt-2", "vocab.json")); 547using Stream mergesStream = File.OpenRead(Path.Combine(@"Gpt-2", "merges.txt")); 592File.WriteAllText(fileName, JsonSerializer.Serialize<Dictionary<string, int>>(dic), Encoding.UTF8); 951using Stream jsonModelStream = File.OpenRead(Path.Combine(@"DeepSeek", "tokenizer-DeepSeek-R1.json"));

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

UnigramTests.cs (2)

26using Stream remoteStream = File.OpenRead(Path.Combine(@"Paraphrase-multilingual-MiniLM-L12-v2", "sentencepiece.bpe.model")); 58using Stream remoteStream = File.OpenRead(Path.Combine(@"Paraphrase-multilingual-MiniLM-L12-v2", "sentencepiece.bpe.model"));

Utils.cs (3)

41if (File.Exists(file)) 45File.Delete(file); 58using Stream fileStream = File.Create(fileName);

WordPieceTests.cs (6)

21File.WriteAllLines(vocabFile, vocabTokens); 32using Stream vocabStream = File.OpenRead(vocabFile); 47File.Delete(vocabFile); 141File.Delete(vocabFile); 173File.Delete(vocabFile); 217File.Delete(vocabFile);

Microsoft.ML.Transforms (6)

LoadTransform.cs (1)

71h.CheckUserArg(File.Exists(args.ModelFile), nameof(args.ModelFile), "File does not exist");

SvmLight\SvmLightLoaderSaverCatalog.cs (2)

72if (!File.Exists(path)) 94if (!File.Exists(path))

Text\WordEmbeddingsExtractor.cs (3)

653if (!File.Exists(_modelFileNameWithPath)) 682Parallel.ForEach(File.ReadLines(_modelFileNameWithPath).Skip(skippedLinesCount), GetParallelOptions(hostEnvironment), 706var firstLine = File.ReadLines(_modelFileNameWithPath).First();

Microsoft.ML.Vision (21)

DnnRetrainTransform.cs (5)

420File.Copy(f, Path.Combine(archivePath, Path.GetFileName(f))); 440if (File.Exists(destination)) 441File.Delete(destination); 447if (File.Exists(destination)) 448File.Delete(destination);

ImageClassificationTrainer.cs (16)

Microsoft.NETCore.Platforms (2)

UpdateRuntimeIdentifierGraph.cs (2)

28using (StreamReader streamReader = File.OpenText(InputFile!)) 47using StreamWriter streamWriter = File.CreateText(OutputFile!);

Microsoft.VisualBasic.Core (27)

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

404If File.Exists(m_sFullPath) Then

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

42If File.Exists(m_sFullPath) Then

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

62If File.Exists(m_sFullPath) Then

Microsoft\VisualBasic\FileIO\FileSystem.vb (18)

97Return IO.File.Exists(file) 347Return IO.File.ReadAllBytes(file) 357Return IO.File.ReadAllText(file) 368Return IO.File.ReadAllText(file, encoding) 478If IO.File.Exists(directory) Then 710If Not IO.File.Exists(file) Then 728IO.File.Move(file, FullNewPath) 795If append AndAlso IO.File.Exists(file) Then 920If IO.File.Exists(TargetDirectoryFullPath) Then 1110If Not IO.File.Exists(sourceFileFullPath) Then 1136IO.File.Copy(sourceFileFullPath, destinationFileFullPath, overwrite) 1159IO.File.Delete(destinationFileFullPath) 1161IO.File.Move(sourceFileFullPath, destinationFileFullPath) 1164IO.File.Move(sourceFileFullPath, destinationFileFullPath) 1230If Not IO.File.Exists(fileFullPath) Then 1240IO.File.Delete(fileFullPath) 1249If IO.File.Exists(Path) Then 1496If IO.File.Exists(FullPath) Then

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

600If Not File.Exists(fullPath) Then

Microsoft\VisualBasic\FileSystem.vb (5)

284File.Copy(Source, Destination, True) 287File.SetAttributes(Destination, FileAttributes.Archive) 307If File.Exists(PathName) Then 318If File.Exists(PathName) Then 415IO.File.Delete(FileName)

Microsoft.VisualBasic.Forms.Tests (22)

System\Windows\Forms\FileLogTraceListenerTests.vb (8)

154If File.Exists(fullLogFileName) Then 155File.Delete(fullLogFileName) 220If File.Exists(fullLogFileName) Then 221File.Delete(fullLogFileName) 241If File.Exists(fullLogFileName) Then 242File.Delete(fullLogFileName) 262If File.Exists(fullLogFileName) Then 263File.Delete(fullLogFileName)

System\Windows\Forms\FileSystemProxyTests.vb (10)

System\Windows\Forms\VbFileCleanupTestBaseTests.vb (1)

51File.Exists(testFile1).Should.BeFalse()

System\Windows\TestUtilities\VbFileCleanupTestBase.vb (3)

52Using destinationStream As FileStream = File.Create(filenameWithPath) 72Using stream As FileStream = File.Create(path) 75File.Delete(path)

Microsoft.VisualBasic.Tests (24)

Microsoft\VisualBasic\MyServices\FileSystemProxyTests.cs (24)

19string actualData = File.ReadAllText(FileNameWithPath); 25File.WriteAllText(FileName, TestData); 212Assert.True(File.Exists(testFileSource)); 225Assert.True(File.Exists(testFileSource)); 228Assert.True(File.Exists(testFileSource)); 236Assert.True(File.Exists(testFileSource)); 238Assert.False(File.Exists(testFileSource)); 257File.Delete(testFileSource); 437Assert.True(File.Exists(FileList[i])); 483Assert.True(File.Exists(TempFile)); 485File.Delete(TempFile); 580Assert.False(File.Exists(SourceFileNameWithPath)); 581Assert.True(File.Exists(DestinationFileNameWithPath)); 589Assert.True(File.Exists(SourceFileNameWithPath)); 598Assert.False(File.Exists(SourceFileNameWithPath)); 599Assert.True(File.Exists(DestinationFileNameWithPath)); 606Assert.True(File.Exists(SourceFileNameWithPath)); 615Assert.False(File.Exists(SourceFileNameWithPath)); 616Assert.True(File.Exists(DestinationFileNameWithPath)); 620Assert.True(File.Exists(SourceFileNameWithPath)); 621Assert.False(File.Exists(DestinationFileNameWithPath)); 674Assert.True(File.Exists(NewFileWithPath)); 675Assert.False(File.Exists(OrigFileWithPath)); 705Assert.False(File.Exists(TempFileNameWithPath), $"File {TempFileNameWithPath} should not exist!");

Microsoft.VisualStudio.LanguageServices (17)

CodeCleanup\AbstractCodeCleanUpFixer.cs (1)

105var attr = File.GetAttributes(path);

EditAndContinue\EditAndContinueFeedbackDiagnosticFileProvider.cs (3)

77if (File.Exists(_vsFeedbackSemaphoreFullPath)) 143if (_vsProcessStartTime > File.GetCreationTime(semaphoreFilePath)) 150var content = File.ReadAllText(semaphoreFilePath);

GenerateType\GenerateTypeDialogViewModel.cs (1)

360File.Exists(FullFilePath))

Implementation\AbstractEditorFactory.cs (1)

409using var stream = File.OpenRead(editorConfigFile);

ProjectSystem\Legacy\AbstractLegacyProject.cs (1)

77if (projectFilePath != null && !File.Exists(projectFilePath))

ProjectSystem\Legacy\AbstractLegacyProject_IVsHierarchyEvents.cs (1)

64if (filePath != null && File.Exists(filePath))

ProjectSystem\MiscellaneousFilesWorkspace.cs (1)

137let fullPath = FileUtilities.ResolveRelativePath(fileName, basePath: null, baseDirectory: null, searchPaths: searchPaths, fileExists: File.Exists)

ProjectSystem\VisualStudioWorkspaceImpl.cs (1)

890if (IOUtilities.PerformIO(() => File.Exists(documentInfo.FilePath)))

Telemetry\FileLogger.cs (2)

105if (!File.Exists(_logFilePath)) 110File.AppendAllText(_logFilePath, buffer.ToString());

UnusedReferences\ProjectAssets\ProjectAssetsFileReader.cs (2)

22var doesProjectAssetsFileExist = IOUtilities.PerformIO(() => File.Exists(projectAssetsFilePath)); 30using var fileStream = File.OpenRead(projectAssetsFilePath);

Watson\FaultReporter.cs (1)

330var lastWrite = File.GetLastWriteTimeUtc(path);

Workspace\SourceGeneratedFileManager.cs (2)

145if (!File.Exists(temporaryFilePath)) 146File.WriteAllText(temporaryFilePath, "");

Microsoft.VisualStudio.LanguageServices.CSharp (2)

SemanticSearch\SemanticSearchToolWindowImpl.cs (2)

476File.Delete(filePath); 480File.WriteAllText(filePath, newContent, Encoding.UTF8);

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

ProjectSystemShim\LegacyProject\AnalyzersTests.cs (1)

260File.WriteAllText(ruleSetFile.Path, ruleSetSource.Replace("Error", "Warning"));

Microsoft.VisualStudio.LanguageServices.Implementation (4)

CodeModel\RootCodeModel.cs (1)

75using (FileUtilities.CreateFileStreamChecked(File.Create, absoluteFilePath))

Options\GridOptionPreviewControl.xaml.cs (1)

121File.WriteAllText(filePath, editorconfig.ToString());

ProjectSystem\CPS\TempPECompiler.cs (1)

90using var file = FileUtilities.CreateFileStreamChecked(File.Create, outputFileName, nameof(outputFileName));

SolutionExplorer\AnalyzersCommandHandler.cs (1)

540File.Copy(pathToRuleSet, fullFilePath);

Microsoft.VisualStudio.LanguageServices.LiveShare (2)

Client\Projects\WorkspaceFileTextLoaderNoException.cs (1)

30if (!File.Exists(Path))

Client\RemoteLanguageServiceWorkspace.cs (1)

302text = SourceText.From(File.ReadAllText(document.FilePath));

mscorlib (1)

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

319[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.IO.File))]

Mvc.Api.Analyzers.Test (2)

Infrastructure\MvcTestSource.cs (2)

16if (!File.Exists(filePath)) 21var fileContent = File.ReadAllText(filePath);

netstandard (1)

netstandard.cs (1)

914[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.IO.File))]

Pipelines.AppHost (1)

AppHost.cs (1)

312using var fileStream = File.OpenRead(filePath);

Pipelines.Library (3)

DistributedApplicationPipelineExtensions.cs (3)

152await using var zipStream = File.OpenRead(zipPath); 175if (File.Exists(zipPath)) 177File.Delete(zipPath);

PrepareTests (6)

MinimizeUtil.cs (6)

104if (isUnix && !OperatingSystem.IsWindows() && File.GetUnixFileMode(sourceFilePath).HasFlag(UnixFileMode.UserExecute)) 180File.WriteAllText(Path.Combine(destinationDirectory, group.Key, fileName), builder.ToString()); 193Contract.Assert(!File.Exists(file)); 194File.WriteAllText(file, "echo \"Nothing to rehydrate\""); 199File.WriteAllText(Path.Combine(destinationDirectory, rehydrateAllFilename), rehydrateAllBuilder.ToString()); 347using var stream = File.OpenRead(filePath);

PresentationBuildTasks (20)

Microsoft\Build\Tasks\Windows\GenerateTemporaryTargetAssembly.cs (4)

117using(FileStream fs = File.OpenRead(CurrentProject)) 195File.Delete(tempProj); 246using(FileStream fs = File.OpenRead(CurrentProject)) 310File.Delete(TemporaryTargetAssemblyProjectName);

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

293if (!File.Exists(TaskHelper.CreateFullFilePath(strFileName, SourceDir)))

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

246using (Stream source = File.OpenRead(inputFile.ItemSpec)) 300using (Stream source = File.OpenRead(inputFile.ItemSpec)) 369File.Move(src, dest); 374if (File.Exists(fileName)) 376File.Delete(fileName); 479using (Stream xamlStream = File.OpenRead(fileName))

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

120_stream = File.OpenRead(_filePath);

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

163stream = File.OpenRead(_stateFilePath);

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

151fileStream = File.OpenRead(srcFile); 199using (Stream fileStream = File.OpenRead(fileName)) 227lastChangeDT = File.GetLastWriteTime(srcFile); 252fileExists = File.Exists(fileName); 274File.Delete(fileName); 356File.Copy(buildFile, intelFile, /*overwrite*/ true);

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

110if (!String.IsNullOrEmpty(assemblyFullPath) && File.Exists(assemblyFullPath))

PresentationCore (4)

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

170return File.OpenRead(_absoluteLocation.LocalPath);

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

60_tempFileStream = File.Open(tempFileName, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite);

src\Microsoft.DotNet.Wpf\src\Shared\System\IO\FileHelper.cs (1)

154File.Delete(filePath);

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

256File.Delete(filePath);

PresentationCore.Tests (4)

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

65File.WriteAllBytes(tempFile, "invalid image"u8.ToArray()); 80File.Delete(tempFile); 91File.WriteAllBytes(tempFile, s_png120DPI1x1); 115File.Delete(tempFile);

PresentationFramework (9)

Microsoft\Win32\FileDialog.cs (2)

459fileExists = File.Exists(tempPath); 600if (!GetOption(FOS.FILEMUSTEXIST) || File.Exists(newFilename))

Microsoft\Win32\SaveFileDialog.cs (1)

187bool fExist = File.Exists(fileName);

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

123return System.IO.File.Open(filename, FileMode.Open, FileAccess.Read, ResourceContainer.FileShare);

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

12578_writer = new BinaryWriter(File.Open(filename, FileMode.Create));

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

1581System.IO.File.Delete(tempLocationUri.LocalPath);

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

5053_writer = new BinaryWriter(File.Open(filename, FileMode.Create));

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

428if (!File.Exists(lexiconFilePath))

System\Windows\Standard\Verify.cs (1)

265if (!File.Exists(filePath))

PresentationUI (23)

InstallationError.xaml.cs (1)

175if (File.Exists(LogFilePath) && ErrorFlag)

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

118File.Copy(sourcePath, copiesPath, true); 123FileAttributes attrib = File.GetAttributes(copiesPath); 126File.SetAttributes(copiesPath, attrib ^ FileAttributes.ReadOnly); 264File.Copy(sourcePath, tempPath, true); 315if (File.Exists(path)) 317attributes = File.GetAttributes(path); 689File.Delete(path); 750File.SetAttributes( 854if (File.Exists(targetFile)) 865if( File.Exists( backupFile ) ) 868File.SetAttributes(backupFile, FileAttributes.Normal); 869File.Delete(backupFile); 874targetAttributes = File.GetAttributes(targetFile); 875File.Move(targetFile, backupFile); 889File.SetAttributes(backupFile, FileAttributes.Normal); 892File.Move(sourceFile, targetFile); 907File.Move(backupFile, targetFile); 914File.SetAttributes(targetFile, targetAttributes); 925File.Delete(backupFile);

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

862foundRMClient = File.Exists(msdrmdllPath); 1436template = File.ReadAllText(templateLocalPath, Encoding.Unicode);

TenFeetInstallationError.xaml.cs (1)

179if (File.Exists(LogFilePath) && ErrorFlag)

Replay (6)

src\Compilers\Shared\BuildServerConnection.cs (4)

439if (!File.Exists(processFilePath)) 529if (!File.Exists(serverInfo.processFilePath)) 821if (!File.Exists(FilePath)) 851File.Delete(FilePath);

src\Compilers\Shared\RuntimeHostInfo.cs (2)

43var resolvedPath = File.ResolveLinkTarget(dotNetPath, returnFinalTarget: true); 91if (File.Exists(filePath))

Roslyn.Compilers.Extension (3)

CompilerPackage.cs (3)

122if (File.Exists(fileAndContents.Key) && File.ReadAllText(fileAndContents.Key) == fileAndContents.Value) 127File.WriteAllText(fileAndContents.Key, fileAndContents.Value);

Roslyn.Diagnostics.Analyzers (5)

src\Compilers\Core\Portable\FileSystem\FileUtilities.cs (1)

399return File.GetLastWriteTimeUtc(fullPath);

src\Compilers\Core\Portable\FileSystem\RelativePathResolver.cs (1)

51return File.Exists(fullPath);

src\RoslynAnalyzers\Utilities\Compiler\RulesetToEditorconfigConverter.cs (2)

38File.WriteAllText(editorconfigFilePath, GetEditorconfig(rulesetFilePath)); 96using Stream stream = File.OpenRead(rulesetFilePath);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Helpers\MefHostServicesHelpers.cs (1)

66if (File.Exists(potentialAssemblyPath))

Roslyn.Test.Performance.Utilities (11)

Benchview.cs (2)

93System.Console.Write(System.IO.File.ReadAllText(submissionJson)); 109if (!File.Exists(source))

Logger.cs (1)

58File.AppendAllText(_file, _buffer.ToString());

RelativeDirectory.cs (2)

107if (File.Exists(zipPath)) 117File.Delete(path);

ScenarioGenerator.cs (3)

68if (File.Exists(_fullPath)) 71File.Delete(_fullPath); 75File.WriteAllLines(_fullPath, _buffer);

TraceManager.cs (1)

20if (File.Exists(cpcFullPath))

VsPerfTest.cs (2)

60var template = File.ReadAllText(taoTestFileTemplatePath); 68File.WriteAllText(Path.Combine(TempDirectory, _testTemplateName), finalTest);

Roslyn.VisualStudio.DiagnosticsWindow (1)

Panels\WorkspacePanel.xaml.cs (1)

94using var fileStream = File.OpenRead(document.FilePath);

RulesetToEditorconfigConverter (2)

src\RoslynAnalyzers\Utilities\Compiler\RulesetToEditorconfigConverter.cs (2)

38File.WriteAllText(editorconfigFilePath, GetEditorconfig(rulesetFilePath)); 96using Stream stream = File.OpenRead(rulesetFilePath);

RulesetToEditorconfigConverter.UnitTests (3)

RulesetToEditorconfigConverterTests.cs (3)

23File.WriteAllText(ruleset, rulesetText); 29File.WriteAllText(includedRuleset, includedRulesetText); 35var actualEditorConfigText = File.ReadAllText(editorconfigPath).Trim();

RunTests (25)

AssemblyScheduler.cs (3)

252if (!File.Exists(testListPath)) 257var deserialized = JsonSerializer.Deserialize<List<string>>(File.ReadAllText(testListPath)); 287using var stream = File.OpenRead(assemblyFilePath);

FileUtil.cs (2)

34if (File.Exists(filePath)) 36File.Delete(filePath);

HelixTestRunner.cs (9)

81File.WriteAllText(helixFilePath, helixProjectFileContent); 98File.Copy(helixFilePath, Path.Combine(logsDir, "helix.proj")); 214File.WriteAllText( 221File.CreateSymbolicLink( 226File.WriteAllText(Path.Combine(workItemPayloadDir, commandFileName), commandContent); 229File.WriteAllText(Path.Combine(workItemPayloadDir, postCommandFileName), postCommandContent); 391var globalJson = JsonConvert.DeserializeAnonymousType(File.ReadAllText(globalJsonFilePath), new { sdk = new { version = "" } }) 401if (File.Exists(globalJsonPath)) 491File.Copy(filePath, destinationPath);

Options.cs (2)

222if (dotnetFilePath is null || !File.Exists(dotnetFilePath)) 277while (dir != null && !File.Exists(Path.Combine(dir, programName)))

ProcessRunner.cs (1)

51if (File.Exists(file))

ProcessTestExecutor.cs (4)

117File.WriteAllText(rspFilePath, rspFileContents); 134File.Create(resultsFilePath).Close(); 163resultData = File.ReadAllText(resultsFilePath).Trim(); 173File.Delete(resultsFilePath);

Program.cs (3)

243if (File.Exists(dumpFilePath)) 320if (File.Exists(filePath)) 433File.Delete(dumpFile);

TestRunner.cs (1)

209File.WriteAllText(outputLogPath, testResult.StandardOutput ?? "");

Security.TransportSecurity.IntegrationTests (1)

Tcp\ClientCredentialTypeTests.OSX.cs (1)

133if (!File.Exists(ServiceUtilHelper.OSXCustomKeychainFilePath))

SemanticSearch.BuildTask (7)

GenerateFilteredReferenceAssembliesTask.cs (7)

90ExecuteImpl(ApiSets.Select(item => (item.ItemSpec, (IReadOnlyList<string>)File.ReadAllLines(item.ItemSpec)))); 116var peImageBuffer = File.ReadAllBytes(originalReferencePath); 122File.WriteAllBytes(filteredReferencePath, peImageBuffer); 124catch when (File.Exists(filteredReferencePath)) 163if (File.Exists(outputFilePath)) 167oldContent = File.ReadAllText(outputFilePath, Encoding.UTF8); 191File.WriteAllText(outputFilePath, newContent, Encoding.UTF8);

ServerComparison.FunctionalTests (1)

Helpers.cs (1)

35var content = File.ReadAllText(Path.Combine(applicationBasePath, nginxConfig));

Sockets.FunctionalTests (1)

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

207File.Delete(path);

Stress.ApiService (2)

Program.cs (2)

294var xmlLarge = File.ReadAllText(Path.Combine("content", "books.xml")); 301var jsonLarge = File.ReadAllText(Path.Combine("content", "example.json"));

Swaggatherer (3)

src\Shared\CommandLineUtils\Utilities\DotNetMuxer.cs (1)

78if (File.Exists(candidateDotNetExePath))

SwaggathererApplication.cs (2)

121File.WriteAllText(Output.Value(), text); 127using (var reader = File.OpenText(input))

System.CodeDom (5)

Microsoft\CSharp\CSharpCodeGenerator.cs (2)

2955File.OpenRead(fileName).Dispose(); 2995File.OpenRead(fileName).Dispose();

src\libraries\Common\src\System\IO\TempFileCollection.cs (1)

186File.Delete(fileName);

System\CodeDom\Compiler\CodeCompiler.cs (2)

77File.OpenRead(fileName).Dispose(); 119File.OpenRead(fileName).Dispose();

System.ComponentModel.TypeConverter (1)

System\ComponentModel\LicFileLicenseProvider.cs (1)

85if (File.Exists(licenseFile))

System.Configuration.ConfigurationManager (21)

src\libraries\Common\src\System\IO\TempFileCollection.cs (1)

186File.Delete(fileName);

System\Configuration\AppSettingsSection.cs (1)

104if (!IO.File.Exists(sourceFileFullPath)) return;

System\Configuration\ClientConfigPaths.cs (1)

47if (!File.Exists(ApplicationUri))

System\Configuration\ConfigurationFileMap.cs (1)

30if (!File.Exists(machineConfigFilename))

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

227return !File.Exists(streamName) 253if (File.Exists(streamName)) 293File.Delete(streamName);

System\Configuration\Internal\WriteFileContext.cs (12)

65if (File.Exists(filename)) 101FileAttributes attributes = File.GetAttributes(source); 102File.SetAttributes(destination, attributes); 105creationTime = File.GetCreationTimeUtc(source); 106File.SetCreationTimeUtc(destination, creationTime); 116FileAttributes fileAttributes = File.GetAttributes(source); 117File.SetAttributes(destination, fileAttributes); 169File.Exists(target) && 188if (File.Exists(target)) 190File.Replace(source, target, null); 194File.Move(source, target); 208if (!File.Exists(fileName))

System\Configuration\LocalFileSettingsProvider.cs (1)

330if (File.Exists(file))

System\Configuration\NameValueFileSectionHandler.cs (1)

43if (File.Exists(sourceFileFullPath))

System.Diagnostics.FileVersionInfo (2)

System\Diagnostics\FileVersionInfo.cs (1)

274if (!File.Exists(fileName))

System\Diagnostics\FileVersionInfo.Unix.cs (1)

49using (FileStream assemblyStream = File.OpenRead(_fileName))

System.Diagnostics.Process (12)

src\libraries\Common\src\Interop\Linux\cgroups\Interop.cgroups.cs (5)

72foreach (string line in File.ReadLines(path + "/memory.stat")) 154if (File.Exists(path)) 158byte[] bytes = File.ReadAllBytes(path); 314if (File.Exists(mountInfoFilePath)) 384if (File.Exists(procCGroupFilePath))

src\libraries\Common\src\Interop\Linux\procfs\Interop.ProcFsStat.ParseMapModules.cs (1)

26return ParseMapsModulesCore(File.ReadLines(GetMapsFilePathForProcess(pid)));

src\libraries\Common\src\Interop\Linux\procfs\Interop.ProcMountInfo.cs (1)

18if (File.Exists(ProcMountInfoFilePath))

System\Diagnostics\Process.Unix.cs (5)

637if (File.Exists(filename)) 645if (uri.IsFile && uri.Host == "" && File.Exists(uri.LocalPath)) 659if (File.Exists(filenameInWorkingDirectory)) 713if (File.Exists(path)) 723if (File.Exists(path))

System.Diagnostics.StackTrace (1)

System\Diagnostics\StackTraceSymbols.cs (1)

225if (!File.Exists(path))

System.Diagnostics.TraceSource (1)

System\Diagnostics\DefaultTraceListener.cs (1)

165File.AppendAllText(LogFileName!, message);

System.Drawing.Common (6)

System\Drawing\Icon.cs (1)

158if (!File.Exists(filePath))

System\Drawing\Image.cs (3)

88if (!File.Exists(filename)) 268using var fs = File.OpenWrite(filename); 922created = dataStream = File.OpenRead(filename ?? throw new InvalidOperationException());

System\Drawing\Text\PrivateFontCollection.cs (1)

53if (!File.Exists(filename))

System\Drawing\ToolboxBitmapAttribute.cs (1)

157using FileStream reader = File.OpenRead(imageFile!);

System.Drawing.Common.Tests (57)

mono\System.Drawing.Imaging\BmpCodecTests.cs (1)

457File.Delete(sOutFile);

mono\System.Drawing.Imaging\GifCodecTests.cs (1)

221File.Delete(sOutFile);

mono\System.Drawing.Imaging\IconCodecTests.cs (1)

1898File.Delete(sOutFile);

mono\System.Drawing.Imaging\JpegCodecTests.cs (1)

379File.Delete(sOutFile);

mono\System.Drawing.Imaging\PngCodecTests.cs (1)

597File.Delete(sOutFile);

mono\System.Drawing.Imaging\TiffCodecTests.cs (1)

268File.Delete(sOutFile);

mono\System.Drawing\BitmapTests.cs (1)

791File.Delete(filename);

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

108using FileStream fs = File.OpenRead(Helpers.GetTestBitmapPath(WmfPlaceable)); 124using MemoryStream ms = new(File.ReadAllBytes(filename)); 169using FileStream fs = File.OpenRead(Helpers.GetTestBitmapPath(Emf)); 179using MemoryStream ms = new(File.ReadAllBytes(filename));

System\Drawing\BitmapTests.cs (5)

119using Stream stream = File.OpenRead(Helpers.GetTestBitmapPath(filename)); 133using Stream stream = File.OpenRead(Helpers.GetTestBitmapPath(filename)); 739using Stream wmfStream = File.OpenRead(Helpers.GetTestBitmapPath("gdiwmfboundariesbug.wmf")); 743using Stream expectedPngStream = File.OpenRead(Helpers.GetTestBitmapPath("gdiwmfboundariesbug-output.png")); 746using Stream outputPngStream = File.OpenRead(output);

System\Drawing\IconTests.cs (8)

97using var stream = File.OpenRead(Helpers.GetTestBitmapPath("48x48_multiple_entries_4bit.ico")); 107TrickleStream stream = new(File.ReadAllBytes(Helpers.GetTestBitmapPath("48x48_multiple_entries_4bit.ico"))); 124using var stream = File.OpenRead(Helpers.GetTestBitmapPath(fileName)); 135using var stream = File.OpenRead(Helpers.GetTestBitmapPath(fileName)); 365File.Open(bitmapUncPath, FileMode.Open, FileAccess.Read, FileShare.Read).Dispose(); 435Assert.Equal(File.ReadAllBytes(filePath), outputStream.ToArray()); 446Assert.Equal(File.ReadAllBytes(filePath), outputStream.ToArray()); 750using var stream = File.OpenRead(Helpers.GetTestBitmapPath("pngwithheight_icon.ico"));

System\Drawing\ImageConverterTests.cs (1)

50using FileStream fileStream = File.Open(path, FileMode.Open);

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

System\Drawing\Text\PrivateFontCollectionTests.cs (2)

138byte[] data = File.ReadAllBytes(Helpers.GetTestFontPath("CodeNewRoman.otf")); 174byte[] data = File.ReadAllBytes(Helpers.GetTestFontPath("CodeNewRoman.otf"));

System.Formats.Tar (11)

src\libraries\Common\src\System\IO\Archiving.Utils.cs (1)

39File.SetLastWriteTime(destinationFileName, lastWriteTime.DateTime);

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

187/// <para>Symbolic links can be recreated using <see cref="File.CreateSymbolicLink(string, string)"/>, <see cref="Directory.CreateSymbolicLink(string, string)"/> or <see cref="FileSystemInfo.CreateAsSymbolicLink(string)"/>.</para> 528File.Delete(filePath); 573File.SetLastWriteTime(destinationFileName, lastWriteTime.UtcDateTime);

System\Formats\Tar\TarEntry.Unix.cs (1)

40File.CreateHardLink(hardLinkFilePath, targetFilePath);

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

264if (!File.Exists(sourceFileName)) 274using FileStream archive = File.OpenRead(sourceFileName); 311if (!File.Exists(sourceFileName))

System\Formats\Tar\TarHelpers.Unix.cs (3)

35UnixFileMode actual = File.GetUnixFileMode(fs.SafeFileHandle); 74File.SetUnixFileMode(fullPath, mode.Value & ~umask); 114File.SetUnixFileMode(dir.Key, dir.Value & ~umask);

System.IO.Compression.ZipFile (2)

src\libraries\Common\src\System\IO\Archiving.Utils.cs (1)

39File.SetLastWriteTime(destinationFileName, lastWriteTime.DateTime);

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

113DateTime lastWrite = File.GetLastWriteTime(sourceFileName);

System.IO.FileSystem (1)

System.IO.FileSystem.cs (1)

10[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.IO.File))]

System.IO.FileSystem.DriveInfo (2)

src\libraries\Common\src\Interop\Linux\procfs\Interop.ProcMountInfo.cs (1)

18if (File.Exists(ProcMountInfoFilePath))

src\libraries\Common\src\Interop\Unix\System.Native\Interop.MountPoints.cs (1)

44if (File.Exists(Interop.procfs.ProcMountInfoFilePath))

System.IO.FileSystem.Watcher (1)

System\IO\FileSystemWatcher.Linux.cs (1)

146try { return File.ReadAllText(path).Trim(); }

System.IO.IsolatedStorage (7)

System\IO\IsolatedStorage\IsolatedStorageFile.cs (7)

83File.Delete(fullPath); 97return File.Exists(GetFullPath(path)); 243return new DateTimeOffset(File.GetCreationTime(GetFullPath(path))); 259return new DateTimeOffset(File.GetLastAccessTime(GetFullPath(path))); 275return new DateTimeOffset(File.GetLastWriteTime(GetFullPath(path))); 303File.Copy(sourceFileNameFullPath, destinationFileNameFullPath, overwrite); 331File.Move(sourceFileNameFullPath, destinationFileNameFullPath);

System.IO.MemoryMappedFiles (4)

System\IO\MemoryMappedFiles\MemoryMappedFile.cs (3)

125_ => File.Exists(path) 127SafeFileHandle fileHandle = File.OpenHandle(path, mode, GetFileAccess(access), FileShare.Read, FileOptions.None); 511File.Delete(path);

System\IO\MemoryMappedFiles\MemoryMappedFile.Unix.cs (1)

324SafeFileHandle fileHandle = File.OpenHandle(path, FileMode.CreateNew, TranslateProtectionsToFileAccess(protections), share);

System.IO.Ports (3)

System\IO\Ports\SerialPort.Unix.cs (3)

56(File.Exists(entry.FullName + "/device/id") || 60(isTtyGS && (File.Exists(entry.FullName + "/dev")))) 63if (File.Exists(deviceName))

System.Memory.Data (2)

System\BinaryData.cs (2)

328return new BinaryData(File.ReadAllBytes(path), mediaType); 360await File.ReadAllBytesAsync(path, cancellationToken).ConfigureAwait(false),

System.Net.Mail (1)

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

372if (!File.Exists(pathAndFilename))

System.Net.NetworkInformation (11)

System\Net\NetworkInformation\LinuxNetworkInterface.cs (5)

33if (File.Exists(NetworkFiles.Ipv4RouteFile)) 37IPv4Routes = File.ReadAllLines(NetworkFiles.Ipv4RouteFile); 44if (File.Exists(NetworkFiles.Ipv6RouteFile)) 48IPv6Routes = File.ReadAllLines(NetworkFiles.Ipv6RouteFile); 57string resolverConfig = File.ReadAllText(NetworkFiles.EtcResolvConfFile);

System\Net\NetworkInformation\StringParsingHelpers.Addresses.cs (2)

87if (File.Exists(filePath)) // avoid an exception in most cases if path doesn't already exist 129if (File.Exists(smbConfFilePath)) // avoid an exception in most cases if path doesn't already exist

System\Net\NetworkInformation\StringParsingHelpers.Misc.cs (2)

19return File.ReadAllLines(filePath); 31return File.ReadAllText(filePath);

System\Net\NetworkInformation\UnixIPInterfaceProperties.cs (2)

91return StringParsingHelpers.ParseDnsSuffixFromResolvConfFile(File.ReadAllText(NetworkFiles.EtcResolvConfFile)); 103List<IPAddress> internalAddresses = StringParsingHelpers.ParseDnsAddressesFromResolvConfFile(File.ReadAllText(NetworkFiles.EtcResolvConfFile));

System.Net.Ping (3)

src\libraries\Common\src\System\Net\NetworkInformation\UnixCommandLinePing.cs (3)

32if (File.Exists(path)) 36if (File.Exists(pathv4v6)) 50System.IO.FileSystemInfo? linkInfo = File.ResolveLinkTarget(pingBinary, returnFinalTarget: true);

System.Net.Quic (1)

src\libraries\Common\src\System\Net\Security\SslKeyLogger.cs (1)

29s_fileStream = File.Open(s_keyLogFile, FileMode.Append, FileAccess.Write, FileShare.ReadWrite);

System.Net.Security (1)

src\libraries\Common\src\System\Net\Security\SslKeyLogger.cs (1)

29s_fileStream = File.Open(s_keyLogFile, FileMode.Append, FileAccess.Write, FileShare.ReadWrite);

System.Net.Sockets (3)

System\Net\Sockets\Socket.cs (2)

3519File.Delete(unixEndPoint.BoundFileName); 3990private static SafeFileHandle? OpenFileHandle(string? name) => string.IsNullOrEmpty(name) ? null : File.OpenHandle(name, FileMode.Open, FileAccess.Read);

System\Net\Sockets\SocketAsyncEventArgs.Unix.cs (1)

259fileHandles[i] = File.OpenHandle(path, FileMode.Open, FileAccess.Read, FileShare.Read, FileOptions.Asynchronous);

System.Net.WebClient (1)

System\Net\WebClient.cs (1)

351File.Delete(fileName);

System.Private.CoreLib (35)

src\libraries\Common\src\Interop\Linux\os-release\Interop.OSReleaseFile.cs (2)

19if (File.Exists(filename)) 24lines = File.ReadAllLines(filename);

src\libraries\Common\src\Interop\Linux\procfs\Interop.ProcMountInfo.cs (1)

18if (File.Exists(ProcMountInfoFilePath))

src\libraries\Common\src\Interop\Unix\System.Native\Interop.MountPoints.cs (1)

44if (File.Exists(Interop.procfs.ProcMountInfoFilePath))

src\libraries\System.Private.CoreLib\src\System\IO\Directory.cs (9)

109FileSystem.SetCreationTime(fullPath, File.GetUtcDateTimeOffset(creationTimeUtc), asDirectory: true); 114return File.GetCreationTime(path); 119return File.GetCreationTimeUtc(path); 131FileSystem.SetLastWriteTime(fullPath, File.GetUtcDateTimeOffset(lastWriteTimeUtc), asDirectory: true); 136return File.GetLastWriteTime(path); 141return File.GetLastWriteTimeUtc(path); 153FileSystem.SetLastAccessTime(fullPath, File.GetUtcDateTimeOffset(lastAccessTimeUtc), asDirectory: true); 158return File.GetLastAccessTime(path); 163return File.GetLastAccessTimeUtc(path);

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

563/// It is not possible to change the compression status of a <see cref="File"/> object

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

78public FileStream Open(FileStreamOptions options) => File.Open(NormalizedPath, options); 102FileStream fileStream = File.Create(NormalizedPath); 138=> new FileStream(NormalizedPath, FileMode.Open, FileAccess.Read, FileShare.Read, File.DefaultBufferSize, false); 196public void Decrypt() => File.Decrypt(FullPath); 199public void Encrypt() => File.Encrypt(FullPath);

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

81set => CreationTimeCore = File.GetUtcDateTimeOffset(value); 93set => LastAccessTimeCore = File.GetUtcDateTimeOffset(value); 105set => LastWriteTimeCore = File.GetUtcDateTimeOffset(value);

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

82/// Unlike <see cref="File.Exists(string?)"/> it returns true for existing, non-regular files like pipes.

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

403if (File.Exists(sharedFilesPath))

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

291if (!File.Exists(normalizedPath)) 357if (!File.Exists(requestedAssemblyPath))

src\libraries\System.Private.CoreLib\src\System\Resources\FileBasedResourceGroveler.cs (2)

72if (File.Exists(path)) 79if (File.Exists(fileName))

src\libraries\System.Private.CoreLib\src\System\Runtime\Loader\AssemblyDependencyResolver.cs (3)

134if (File.Exists(assemblyPath)) 148if (File.Exists(assemblyPath)) 182if (File.Exists(libraryPath))

src\libraries\System.Private.CoreLib\src\System\TimeZoneInfo.Unix.NonAndroid.cs (4)

37using FileStream fs = File.OpenRead(path); 268using (SafeFileHandle sfh = File.OpenHandle(filePath, FileMode.Open, FileAccess.Read, FileShare.Read)) 353if (File.Exists(tzFilePath)) 357rawData = File.ReadAllBytes(tzFilePath);

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

TempFile.cs (5)

33File.WriteAllBytes(path, data); 41File.WriteAllText(path, text); 64public void AssertExists() => Assert.True(File.Exists(Path)); 66public string ReadAllText() => File.ReadAllText(Path); 77{ File.Delete(Path); }

System.Private.Xml (3)

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

239if ((string.IsNullOrEmpty(path) || !File.Exists(path)) && !string.IsNullOrEmpty(Assembly.GetEntryAssembly()?.Location)) 244if ((string.IsNullOrEmpty(path) || !File.Exists(path)) && !string.IsNullOrEmpty(AppContext.BaseDirectory))

System\Xml\Xsl\IlGen\XmlILTrace.cs (1)

67File.Delete(s_dirName + "\\" + fileName);

System.Reflection.MetadataLoadContext (3)

System\Reflection\MetadataLoadContext.Apis.cs (1)

133return LoadFromStreamCore(File.OpenRead(assemblyPath));

System\Reflection\TypeLoading\Assemblies\Ecma\EcmaAssembly.Modules.cs (2)

46if (File.Exists(modulePath)) 47return File.OpenRead(modulePath);

System.Runtime (1)

artifacts\obj\System.Runtime\Debug\net11.0\System.Runtime.Forwards.cs (1)

301[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.IO.File))]

System.Runtime.Caching (1)

System\Runtime\Caching\FileChangeNotificationSystem.cs (1)

137lastWriteTime = File.GetLastWriteTime(filePath);

System.Security.Cryptography (15)

src\libraries\Common\src\System\Security\Cryptography\X509Certificates\X509CertificateLoader.cs (1)

593using (FileStream stream = File.OpenRead(path))

System\Security\Cryptography\X509Certificates\OpenSslCrlCache.cs (1)

147nextUpdate = File.GetLastWriteTime(crlFile).AddDays(3);

System\Security\Cryptography\X509Certificates\OpenSslDirectoryBasedStoreProvider.cs (5)

196File.SetUnixFileMode(existingFilename, UserReadWrite); 213UnixFileMode actualMode = File.GetUnixFileMode(stream.SafeFileHandle); 249File.Delete(currentFilename); 310if (!File.Exists(builtPath)) 380UnixFileMode permissions = File.GetUnixFileMode(path);

System\Security\Cryptography\X509Certificates\X509Certificate2.cs (6)

1225/// See <see cref="System.IO.File.ReadAllText(string)" /> for additional documentation about 1251ReadOnlySpan<char> certContents = File.ReadAllText(certPemFilePath); 1252ReadOnlySpan<char> keyContents = keyPemFilePath is null ? certContents : File.ReadAllText(keyPemFilePath); 1294/// See <see cref="System.IO.File.ReadAllText(string)" /> for additional documentation about 1317ReadOnlySpan<char> certContents = File.ReadAllText(certPemFilePath); 1318ReadOnlySpan<char> keyContents = keyPemFilePath is null ? certContents : File.ReadAllText(keyPemFilePath);

System\Security\Cryptography\X509Certificates\X509Certificate2Collection.cs (2)

392/// See <see cref="System.IO.File.ReadAllText(string)" /> for additional documentation about 415ReadOnlySpan<char> contents = System.IO.File.ReadAllText(certPemFilePath);

System.Windows.Forms (6)

System\Windows\Forms\Controls\PictureBox\PictureBox.cs (1)

572_fileStream = File.OpenRead(_imageLocation!);

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

2622FileStream file = File.Create(path);

System\Windows\Forms\Dialogs\CommonDialogs\FileDialog.cs (1)

445return File.Exists(fileName);

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

256if (!File.Exists(localPath)) 279if (!File.Exists(localPath))

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

73_cursorData = File.ReadAllBytes(fileName);

System.Windows.Forms.Analyzers.CSharp.Tests (2)

Analyzers\AvoidPassingTaskWithoutCancellationToken\AvoidPassingTaskWithoutCancellationTokenTest.cs (1)

102Assert.True(pathToWinFormsAssembly == "" || File.Exists(pathToWinFormsAssembly));

Analyzers\WFO1001\ImplementITypedDataObjectTests.cs (1)

144Assert.True(File.Exists(CurrentReferences.WinFormsRefPath));

System.Windows.Forms.Analyzers.Tests (3)

CurrentReferences.cs (3)

124if (File.Exists(globalJsonPath)) 141string globalJsonString = File.ReadAllText(globalJsonPath); 154string configJsonString = File.ReadAllText(configJsonPath);

System.Windows.Forms.Design (2)

System\ComponentModel\Design\ByteViewer.cs (1)

672SetBytes(File.ReadAllBytes(path));

System\Drawing\BitmapSelector.cs (1)

50return File.Exists(newPath) ? newPath : originalPath;

System.Windows.Forms.Design.Tests (5)

System\ComponentModel\Design\ByteViewerTests.cs (2)

601Assert.Equal(new byte[] { 1, 2, 3 }, File.ReadAllBytes(path)); 605File.Delete(path);

System\Drawing\Design\BitmapEditorTests.cs (1)

90using Stream stream = File.OpenRead("Resources/telescope_01.wmf");

System\Drawing\Design\ImageEditorTests.cs (1)

147using Stream stream = File.OpenRead("Resources/telescope_01.wmf");

System\Drawing\Design\MetafileEditorTests.cs (1)

69using Stream stream = File.OpenRead("Resources/telescope_01.wmf");

System.Windows.Forms.IntegrationTests.Common (4)

TestHelpers.cs (4)

62if (!File.Exists(exePath)) 82if (!File.Exists(path)) 186if (!File.Exists(jsonFile)) 190string jsonContents = File.ReadAllText(jsonFile);

System.Windows.Forms.Primitives (1)

System\Windows\Forms\Internals\ThemingScope.cs (1)

114File.Delete(tempFilePath);

System.Windows.Forms.Primitives.TestUtilities (2)

Metafiles\EmfValidateHelper.cs (1)

32File.AppendAllText(@$"c:\temp\{methodName}.md", sb.ToString());

PlatformDetection.Windows.cs (1)

55File.Exists(Path.Join(Environment.GetFolderPath(Environment.SpecialFolder.Windows), "System32", "httpapi.dll"));

System.Windows.Forms.Tests (13)

System\Resources\ResXResourceSetTests.cs (2)

21Assert.True(File.Exists(resxFileName), $@"RESX file ""{resxFileName}"" not found, make sure it's in the root folder of the unit test project"); 41Assert.True(File.Exists(resxFileName), $@"RESX file ""{resxFileName}"" not found, make sure it's in the root folder of the unit test project");

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

39byte[] data = File.ReadAllBytes(Path.Join("bitmaps", "10x16_one_entry_32bit.ico")); 129byte[] data = File.ReadAllBytes(Path.Join("bitmaps", "10x16_one_entry_32bit.ico")); 140byte[] data = File.ReadAllBytes(fileName);

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

68using MemoryStream stream = new(File.ReadAllBytes(fileName)); 79using MemoryStream stream = new(File.ReadAllBytes(Path.Join("bitmaps", "cursor.cur"))); 112using MemoryStream stream = new(File.ReadAllBytes(fileName));

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

10697File.Delete(filePath); 10717File.Exists(filePath).Should().BeTrue(); 10721File.Delete(filePath);

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

25if (File.Exists(configuration.FilePath)) 27File.Delete(configuration.FilePath);

System.Windows.Forms.UI.IntegrationTests (10)

DragDropTests.cs (9)

149if (!File.Exists(dragAcceptRtfDestPath)) 151File.Copy(dragAcceptRtfSourcePath, dragAcceptRtfDestPath); 159richTextBox.Rtf = File.ReadAllText(dragAcceptRtfDestPath); 237if (File.Exists(dragAcceptRtfDestPath)) 239File.Delete(dragAcceptRtfDestPath); 427richTextBox.Rtf = File.ReadAllText(dragAcceptRtfPath); 457richTextBox.Rtf = File.ReadAllText(dragAcceptRtfPath); 1085if (File.Exists(dragAcceptRtf)) 1145if (File.Exists(dragAcceptRtf))

Infra\DataCollectionService.cs (1)

171File.WriteAllText(CreateLogFileName(logDir, timestamp, testName, errorId, logId: string.Empty, "log"), exceptionDetails.ToString());

Templates.Blazor.Tests (40)

BlazorWasmTemplateTest.cs (6)

30Assert.False(File.Exists(Path.Combine(publishDir, "service-worker-assets.js")), "Non-PWA templates should not produce service-worker-assets.js"); 109Assert.False(File.Exists(Path.Combine(publishDir, "service-worker.published.js")), "service-worker.published.js should not be published"); 110Assert.True(File.Exists(Path.Combine(publishDir, "service-worker.js")), "service-worker.js should be published"); 111Assert.True(File.Exists(Path.Combine(publishDir, "service-worker-assets.js")), "service-worker-assets.js should be published"); 128var doesExist = File.Exists(fullPath); 131return File.ReadAllText(Path.Combine(basePath, path));

src\ProjectTemplates\Shared\BlazorTemplateTest.cs (2)

108var doesExist = File.Exists(fullPath); 111return File.ReadAllText(Path.Combine(basePath, path));

src\ProjectTemplates\Shared\DevelopmentCertificate.cs (3)

26using var file = File.OpenRead(json); 32if (!File.Exists(path)) 47if (File.Exists(location))

src\ProjectTemplates\Shared\Project.cs (7)

274var contents = File.ReadAllText(file); 300var doesExist = File.Exists(fullPath); 318using var launchSettingsFile = File.OpenRead(filePath); 359var projectFileContents = await File.ReadAllTextAsync(projectFile); 411return File.ReadAllText(Path.Combine(TemplateOutputDir, path)); 534Assert.True(File.Exists(sourceFile), $"Log for '{ProjectName}' not found in '{sourceFile}'. Execution output: {result.Output}"); 536File.Move(sourceFile, destination, overwrite: true); // binlog will exist on retries

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

src\Shared\CertificateGeneration\MacOSCertificateManager.cs (9)

src\Shared\CertificateGeneration\UnixCertificateManager.cs (7)

src\Shared\CommandLineUtils\Utilities\DotNetMuxer.cs (1)

78if (File.Exists(candidateDotNetExePath))

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

src\ProjectTemplates\Shared\BlazorTemplateTest.cs (2)

108var doesExist = File.Exists(fullPath); 111return File.ReadAllText(Path.Combine(basePath, path));

src\ProjectTemplates\Shared\DevelopmentCertificate.cs (3)

26using var file = File.OpenRead(json); 32if (!File.Exists(path)) 47if (File.Exists(location))

src\ProjectTemplates\Shared\Project.cs (7)

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

src\Shared\CertificateGeneration\MacOSCertificateManager.cs (9)

src\Shared\CertificateGeneration\UnixCertificateManager.cs (7)

src\Shared\CommandLineUtils\Utilities\DotNetMuxer.cs (1)

78if (File.Exists(candidateDotNetExePath))

src\Shared\E2ETesting\BrowserAssertFailedException.cs (1)

27if (File.Exists(screenShotPath))

src\Shared\E2ETesting\SauceConnectServer.cs (3)

222if (pidFilePath != null && File.Exists(pidFilePath)) 224File.Delete(pidFilePath); 240await File.WriteAllTextAsync(pidFile, process.Id.ToString(CultureInfo.InvariantCulture));

Templates.Blazor.WebAssembly.Tests (42)

BlazorWasmTemplateTest.cs (4)

36Assert.False(File.Exists(Path.Combine(publishDir, "service-worker-assets.js")), "Non-PWA templates should not produce service-worker-assets.js"); 46Assert.False(File.Exists(Path.Combine(publishDir, "service-worker-assets.js")), "Non-PWA templates should not produce service-worker-assets.js"); 56Assert.False(File.Exists(Path.Combine(publishDir, "service-worker-assets.js")), "Non-PWA templates should not produce service-worker-assets.js"); 66Assert.False(File.Exists(Path.Combine(publishDir, "service-worker-assets.js")), "Non-PWA templates should not produce service-worker-assets.js");

src\ProjectTemplates\Shared\BlazorTemplateTest.cs (2)

108var doesExist = File.Exists(fullPath); 111return File.ReadAllText(Path.Combine(basePath, path));

src\ProjectTemplates\Shared\DevelopmentCertificate.cs (3)

26using var file = File.OpenRead(json); 32if (!File.Exists(path)) 47if (File.Exists(location))

src\ProjectTemplates\Shared\Project.cs (7)

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

src\Shared\CertificateGeneration\MacOSCertificateManager.cs (9)

src\Shared\CertificateGeneration\UnixCertificateManager.cs (7)

src\Shared\CommandLineUtils\Utilities\DotNetMuxer.cs (1)

78if (File.Exists(candidateDotNetExePath))

src\Shared\E2ETesting\BrowserAssertFailedException.cs (1)

27if (File.Exists(screenShotPath))

src\Shared\E2ETesting\SauceConnectServer.cs (3)

222if (pidFilePath != null && File.Exists(pidFilePath)) 224File.Delete(pidFilePath); 240await File.WriteAllTextAsync(pidFile, process.Id.ToString(CultureInfo.InvariantCulture));

Templates.Mvc.Tests (46)

BlazorTemplateTest.cs (6)

177if (File.Exists(singleProjectPath)) 179return File.ReadAllTextAsync(singleProjectPath); 183if (File.Exists(multiProjectPath)) 187return File.ReadAllTextAsync(multiProjectPath); 196var appRazorText = await File.ReadAllTextAsync(appRazorPath); 198await File.WriteAllTextAsync(appRazorPath, appRazorText);

RazorPagesTemplateTest.cs (2)

311var doesExist = File.Exists(fullPath); 314return File.ReadAllText(Path.Combine(basePath, path));

src\ProjectTemplates\Shared\BlazorTemplateTest.cs (2)

108var doesExist = File.Exists(fullPath); 111return File.ReadAllText(Path.Combine(basePath, path));

src\ProjectTemplates\Shared\DevelopmentCertificate.cs (3)

26using var file = File.OpenRead(json); 32if (!File.Exists(path)) 47if (File.Exists(location))

src\ProjectTemplates\Shared\Project.cs (7)

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

src\Shared\CertificateGeneration\MacOSCertificateManager.cs (9)

src\Shared\CertificateGeneration\UnixCertificateManager.cs (7)

src\Shared\CommandLineUtils\Utilities\DotNetMuxer.cs (1)

78if (File.Exists(candidateDotNetExePath))

src\Shared\E2ETesting\BrowserAssertFailedException.cs (1)

27if (File.Exists(screenShotPath))

src\Shared\E2ETesting\SauceConnectServer.cs (3)

222if (pidFilePath != null && File.Exists(pidFilePath)) 224File.Delete(pidFilePath); 240await File.WriteAllTextAsync(pidFile, process.Id.ToString(CultureInfo.InvariantCulture));

Templates.Tests (42)

BaselineTest.cs (2)

109var namespaceDeclaration = File.ReadLines(file) 125var doesExist = File.Exists(fullPath);

IdentityUIPackageTest.cs (2)

162var doesExist = File.Exists(fullPath); 165return File.ReadAllText(Path.Combine(basePath, path));

src\ProjectTemplates\Shared\BlazorTemplateTest.cs (2)

108var doesExist = File.Exists(fullPath); 111return File.ReadAllText(Path.Combine(basePath, path));

src\ProjectTemplates\Shared\DevelopmentCertificate.cs (3)

26using var file = File.OpenRead(json); 32if (!File.Exists(path)) 47if (File.Exists(location))

src\ProjectTemplates\Shared\Project.cs (7)

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

src\Shared\CertificateGeneration\MacOSCertificateManager.cs (9)

src\Shared\CertificateGeneration\UnixCertificateManager.cs (7)

src\Shared\CommandLineUtils\Utilities\DotNetMuxer.cs (1)

78if (File.Exists(candidateDotNetExePath))

src\Shared\E2ETesting\BrowserAssertFailedException.cs (1)

27if (File.Exists(screenShotPath))

src\Shared\E2ETesting\SauceConnectServer.cs (3)

222if (pidFilePath != null && File.Exists(pidFilePath)) 224File.Delete(pidFilePath); 240await File.WriteAllTextAsync(pidFile, process.Id.ToString(CultureInfo.InvariantCulture));

Test.Utilities (4)

src\Compilers\Core\Portable\FileSystem\FileUtilities.cs (1)

399return File.GetLastWriteTimeUtc(fullPath);

src\Compilers\Core\Portable\FileSystem\RelativePathResolver.cs (1)

51return File.Exists(fullPath);

src\RoslynAnalyzers\Utilities\Compiler\RulesetToEditorconfigConverter.cs (2)

38File.WriteAllText(editorconfigFilePath, GetEditorconfig(rulesetFilePath)); 96using Stream stream = File.OpenRead(rulesetFilePath);

TestTasks (3)

InjectRequestHandler.cs (3)

27using (var file = File.OpenText(depsFile)) 61File.Copy(Path.Combine(outputFolder, bitnessString, aspnetcoreV2Name), Path.Combine(outputFolder, aspnetcoreV2Name), overwrite: true); 81using (var file = File.CreateText(depsFile))

Text.Analyzers (5)

src\Compilers\Core\Portable\FileSystem\FileUtilities.cs (1)

399return File.GetLastWriteTimeUtc(fullPath);

src\Compilers\Core\Portable\FileSystem\RelativePathResolver.cs (1)

51return File.Exists(fullPath);

src\RoslynAnalyzers\Utilities\Compiler\RulesetToEditorconfigConverter.cs (2)

38File.WriteAllText(editorconfigFilePath, GetEditorconfig(rulesetFilePath)); 96using Stream stream = File.OpenRead(rulesetFilePath);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Helpers\MefHostServicesHelpers.cs (1)

66if (File.Exists(potentialAssemblyPath))

vbc (6)

src\Compilers\Shared\BuildServerConnection.cs (4)

439if (!File.Exists(processFilePath)) 529if (!File.Exists(serverInfo.processFilePath)) 821if (!File.Exists(FilePath)) 851File.Delete(FilePath);

src\Compilers\Shared\RuntimeHostInfo.cs (2)

43var resolvedPath = File.ResolveLinkTarget(dotNetPath, returnFinalTarget: true); 91if (File.Exists(filePath))

VBCSCompiler (7)

src\Compilers\Server\VBCSCompiler\AnalyzerConsistencyChecker.cs (1)

88string? resolvedPath = FileUtilities.ResolveRelativePath(analyzerReference.FilePath, basePath: null, baseDirectory: baseDirectory, searchPaths: SpecializedCollections.EmptyEnumerable<string>(), fileExists: File.Exists);

src\Compilers\Shared\BuildServerConnection.cs (4)

439if (!File.Exists(processFilePath)) 529if (!File.Exists(serverInfo.processFilePath)) 821if (!File.Exists(FilePath)) 851File.Delete(FilePath);

src\Compilers\Shared\RuntimeHostInfo.cs (2)

43var resolvedPath = File.ResolveLinkTarget(dotNetPath, returnFinalTarget: true); 91if (File.Exists(filePath))

VBCSCompiler.UnitTests (15)

AnalyzerConsistencyCheckerTests.cs (1)

150File.Delete(mvidAlpha1.Path);

CompilerServerTests.cs (12)

TouchedFileLoggingTests.cs (2)

188File.ReadAllText(touchedReadPath).Trim()); 192File.ReadAllText(touchedWritesPath).Trim());

Wasm.Performance.ConsoleHost (1)

src\Shared\CommandLineUtils\Utilities\DotNetMuxer.cs (1)

78if (File.Exists(candidateDotNetExePath))

WindowsBase.Tests (2)

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

42using var stream = File.OpenRead(path); 50using var stream = File.OpenRead(path);

WinFormsControlsTest (2)

DragDrop.cs (1)

410return File.ReadAllText(nyanCatAsciiPath);

RichTextBoxes.cs (1)

17richTextBox1.LoadFile(File.OpenRead(@"Data\example.rtf"), RichTextBoxStreamType.RichText);

WinShimmer (1)

Program.cs (1)

31if (!File.Exists(exePath))

xunit.console (11)

CommandLine.cs (2)

19fileExists = File.Exists; 118var rspLines = File.ReadAllLines(path);

common\AssemblyResolution\AssemblyHelper.cs (1)

31if (!File.Exists(assemblyFileName))

common\AssemblyResolution\Microsoft.DotNet.PlatformAbstractions\Native\PlatformApis.cs (2)

101if (File.Exists("/etc/os-release")) 103var lines = File.ReadAllLines("/etc/os-release");

common\AssemblyResolution\Microsoft.Extensions.DependencyModel\FileWrapper.cs (4)

13return File.Exists(path); 18return File.ReadAllText(path); 23return File.OpenRead(path); 41var emptyFile = File.Create(path);

ConsoleRunner.cs (1)

435if (string.IsNullOrWhiteSpace(fileName) || File.Exists(fileName))

Utility\TransformFactory.cs (1)

66using (var stream = File.Create(outputFileName))