Path

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

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

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

Microsoft.ML.SamplesUtils (11)

SamplesDatasetUtils.cs (11)

27while (!Directory.Exists(Path.Combine(directory, ".git")) && directory != null) 36return Path.Combine(directory, "test", "data", fileName); 179string varPath = Path.Combine(path, "variables"); 183Download(Path.Combine(remotePath, "saved_model.pb"), Path.Combine(path, "saved_model.pb")).Wait(); 184Download(Path.Combine(remotePath, "imdb_word_index.csv"), Path.Combine(path, "imdb_word_index.csv")).Wait(); 185Download(Path.Combine(remotePath, "variables", "variables.data-00000-of-00001"), Path.Combine(varPath, "variables.data-00000-of-00001")).Wait(); 186Download(Path.Combine(remotePath, "variables", "variables.index"), Path.Combine(varPath, "variables.index")).Wait();

Microsoft.ML.SearchSpace.Tests (2)

TestBase.cs (2)

41return Path.Combine(testDataDir.FullName, fileName).Replace(cwd, "."); 53return Path.Combine(testDataDir.FullName, folderName).Replace(cwd, ".");

Microsoft.ML.Sweeper (5)

ConfigRunner.cs (4)

94return Path.Combine(SweepCommand.LocalExePath, "../Win/maml.exe"); 96return Path.Combine(SweepCommand.LocalExePath, "../Linux/maml"); 107string currentDirectory = Path.GetDirectoryName(typeof(ExeConfigRunnerBase).Module.FullyQualifiedName); 134var folderPath = Path.GetFullPath(folderName);

SweepCommand.cs (1)

49public static readonly string LocalExePath = Path.GetDirectoryName(typeof(SweepCommand).Module.FullyQualifiedName);

Microsoft.ML.TensorFlow (11)

TensorflowTransform.cs (7)

154var tempDirPath = Path.GetFullPath(Path.Combine(((IHostEnvironmentInternal)env).TempFilePath, nameof(TensorFlowTransformer) + "_" + Guid.NewGuid())); 166string fullFilePath = Path.Combine(tempDirPath, relativeFile); 167string fullFileDir = Path.GetDirectoryName(fullFilePath); 472Path.Combine(_savedModelPath, DefaultModelFileNames.Graph), 473Path.Combine(_savedModelPath, DefaultModelFileNames.VariablesFolder, DefaultModelFileNames.Index) 475modelFilePaths.AddRange(Directory.GetFiles(Path.Combine(_savedModelPath, DefaultModelFileNames.VariablesFolder), DefaultModelFileNames.Data, SearchOption.TopDirectoryOnly));

TensorflowUtils.cs (4)

219var directory = Path.GetDirectoryName(errorResult.FileName); 220var name = Path.GetFileName(errorResult.FileName); 635string tempDirectory = Path.Combine(((IHostEnvironmentInternal)env).TempFilePath, Path.GetRandomFileName());

Microsoft.ML.TensorFlow.Tests (53)

TensorFlowEstimatorTests.cs (3)

154var imageFolder = Path.GetDirectoryName(dataFile); 196var imageFolder = Path.GetDirectoryName(dataFile); 247var imageFolder = Path.GetDirectoryName(dataFile);

TensorflowTests.cs (50)

Microsoft.ML.TestFramework (23)

BaseTestBaseline.cs (12)

37private readonly string _logRootRelPath = Path.Combine("Logs", BuildString); // Relative to OutDir. 94string baselineRootDir = Path.Combine(RootDir, TestDir, "BaselineOutput"); 97_baselineCommonDir = Path.Combine(baselineRootDir, "Common"); 100string logDir = Path.Combine(OutDir, _logRootRelPath); 103string logPath = Path.Combine(logDir, FullTestName + LogSuffix); 288baselinePath = Path.GetFullPath(Path.Combine(_baselineCommonDir, subDir, baselineConfigDir, name)); 297return Path.GetFullPath(Path.Combine(_baselineCommonDir, subDir, name)); 411Contracts.Assert(!Path.IsPathRooted(name), "file name should not be a full path"); 412Contracts.Assert(!Path.IsPathRooted(nameBase), "file nameBase should not be a full path"); 414string relPath = Path.Combine(dir, name);

BaseTestClass.cs (6)

CopyAction.cs (3)

50if (Path.PathSeparator == '/') copyfolder = "Linux"; 52var dir = new DirectoryInfo(Path.Combine(deploymentDirectory, copyfolder)); 54CopyAll(Path.Combine(deploymentDirectory, "AutoLoad"), testDirectory.FullName);

DataPipe\PartitionedFileLoaderTests.cs (2)

30string pathData = Path.Combine(basePath, "...", "*.csv"); 44string pathData = Path.Combine(basePath, "...", "*.csv");

Microsoft.ML.TestFrameworkCommon (18)

TestCommon.cs (8)

18return Path.Combine(outDir, name); 27return Path.Combine(outDir, subDir, name); // REVIEW: put the path in in braces in case the path has spaces 34return Path.GetFullPath(Path.Combine(dataDir, name)); 40return Path.GetFullPath(Path.Combine(dataDir, subDir, name)); 76while (!Directory.Exists(Path.Combine(directory, ".git")) && directory != null) 293Directory.CreateDirectory(Path.Combine(outDir, subDir));

Utility\LibraryLoader.cs (2)

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

Utility\PathResolver.cs (8)

46yield return Path.Combine(AppContext.BaseDirectory, name); 95if (Path.GetFileName(nativeAsset) == name || Path.GetFileNameWithoutExtension(nativeAsset) == name) 97appLocalNativePath = Path.Combine( 100appLocalNativePath = Path.GetFullPath(appLocalNativePath); 102depsResolvedPath = Path.Combine( 107depsResolvedPath = Path.GetFullPath(depsResolvedPath); 151return Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".nuget", "packages");

Microsoft.ML.Tests (49)

DatabaseLoaderTests.cs (4)

295var databaseFile = Path.GetFullPath(Path.Combine("TestDatabases", $"{databaseName}.mdf")); 301var databaseFile = Path.GetFullPath(Path.Combine("TestDatabases", $"{databaseName}.sqlite"));

ImagesTests.cs (22)

OnnxConversionTest.cs (14)

OnnxSequenceTypeWithAttributesTest.cs (2)

59var modelFile = Path.Combine(Directory.GetCurrentDirectory(), "zipmap", "TestZipMapString.onnx"); 98var modelFile = Path.Combine(Directory.GetCurrentDirectory(), "zipmap", "TestZipMapString.onnx");

TextLoaderTests.cs (1)

595var combinedPath = Path.Combine(directoryName, "*");

TrainerEstimators\TreeEnsembleFeaturizerTest.cs (2)

618var tempPath = Path.GetTempFileName(); 675var tempPath = Path.GetTempFileName();

Transformers\ConcatTests.cs (2)

85var subdir = Path.Combine("Transform", "Concat"); 149var subdir = Path.Combine("Transform", "Concat");

Transformers\NormalizerTests.cs (1)

1005var modelPath = Path.Combine("TestModels", "normalizer_verwrit-00010001.zip");

Transformers\TextFeaturizerTests.cs (1)

750var modelPath = Path.Combine("TestModels", "SentimentModel.zip");

Microsoft.ML.TimeSeries.Tests (4)

TimeSeries.cs (3)

31TestCore(GetDataPath(Path.Combine("Timeseries", "real_1.csv")), 47TestCore(GetDataPath(Path.Combine("Timeseries", "real_11.csv")), 63TestCore(GetDataPath(Path.Combine("Timeseries", "A4Benchmark-TS2.csv")),

TimeSeriesDirectApi.cs (1)

536var dataPath = GetDataPath(Path.Combine("Timeseries", "anomaly_detection.csv"));

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

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

53Path.Combine(Path.GetTempPath(), Path.ChangeExtension(Guid.NewGuid().ToString(), extension));

Microsoft.ML.Tokenizers.Tests (26)

BpeTests.cs (7)

353using Stream vocabStream = File.OpenRead(Path.Combine(@"Gpt-2", "vocab.json")); 354using Stream mergesStream = File.OpenRead(Path.Combine(@"Gpt-2", "merges.txt")); 367string vocabFile = Path.Combine(@"Gpt-2", "vocab.json"); 368string mergesFile = Path.Combine(@"Gpt-2", "merges.txt"); 533using Stream vocabStream = File.OpenRead(Path.Combine(@"Gpt-2", "vocab.json")); 534using Stream mergesStream = File.OpenRead(Path.Combine(@"Gpt-2", "merges.txt")); 878using 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 (6)

91Path.Combine(@"Gpt-2", "vocab.json"), 92Path.Combine(@"Gpt-2", "merges.txt"), 93Path.Combine(@"Gpt-2", "dict.txt"), 109string vocabFile = Path.Combine(@"Gpt-2", "vocab.json"); 110string mergeFile = Path.Combine(@"Gpt-2", "merges.txt"); 111string translationFile = Path.Combine(@"Gpt-2", "dict.txt");

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"));

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)

53Path.Combine(Path.GetTempPath(), Path.ChangeExtension(Guid.NewGuid().ToString(), extension));

WordPieceTests.cs (1)

20string vocabFile = Path.GetTempFileName();

Microsoft.ML.TorchSharp (12)

AutoFormerV2\ObjectDetectionTrainer.cs (4)

261var destDir = Path.Combine(((IHostEnvironmentInternal)Parent.Host).TempFilePath, "mlnet"); 266string relativeFilePath = Path.Combine(destDir, destFileName); 276var directory = Path.GetDirectoryName(errorResult.FileName); 277var name = Path.GetFileName(errorResult.FileName);

Roberta\QATrainer.cs (4)

245var destDir = Path.Combine(((IHostEnvironmentInternal)Parent.Host).TempFilePath, "mlnet"); 250string relativeFilePath = Path.Combine(destDir, destFileName); 260var directory = Path.GetDirectoryName(errorResult.FileName); 261var name = Path.GetFileName(errorResult.FileName);

TorchSharpBaseTrainer.cs (4)

171var destDir = Path.Combine(((IHostEnvironmentInternal)Parent.Host).TempFilePath, "mlnet"); 176string relativeFilePath = Path.Combine(destDir, destFileName); 186var directory = Path.GetDirectoryName(errorResult.FileName); 187var name = Path.GetFileName(errorResult.FileName);

Microsoft.ML.TorchSharp.Tests (1)

ObjectDetectionTests.cs (1)

31var imageFolder = Path.GetDirectoryName(dataFile);

Microsoft.ML.Transforms (5)

Text\StopWordsRemovingTransformer.cs (1)

790var ext = Path.GetExtension(dataFile);

Text\TextFeaturizingEstimator.cs (1)

754var mapperDirName = Path.Combine(dirName, "Mapper");

Text\WordEmbeddingsExtractor.cs (3)

632string dir = kind == WordEmbeddingEstimator.PretrainedModelKind.SentimentSpecificWordEmbedding ? Path.Combine("Text", "Sswe") : "WordVectors"; 639var directory = Path.GetDirectoryName(errorResult.FileName); 640var name = Path.GetFileName(errorResult.FileName);

Microsoft.ML.Vision (25)

DnnRetrainTransform.cs (16)

ImageClassificationTrainer.cs (9)

537_resourcePath = Path.Combine(((IHostEnvironmentInternal)env).TempFilePath, "MLNET"); 570_checkpointPath = Path.Combine(_options.WorkspacePath, _options.FinalModelPrefix + 572_sizeFile = Path.Combine(_options.WorkspacePath, "TrainingSetSize.txt"); 668string trainSetBottleneckCachedValuesFilePath = Path.Combine(_options.WorkspacePath, 671string validationSetBottleneckCachedValuesFilePath = Path.Combine(_options.WorkspacePath, 872Path.Combine(_options.WorkspacePath, _options.ValidationSetBottleneckCachedValuesFileName), 970trainWriter = tf.summary.FileWriter(Path.Combine(_options.WorkspacePath, "train"), 1165var evalGraph = LoadMetaGraph(Path.Combine(_resourcePath, ModelFileName[_options.Arch])); 1329var modelFilePath = Path.Combine(_resourcePath, modelFileName);

Microsoft.VisualBasic.Core (78)

Microsoft\VisualBasic\CompilerServices\IOUtils.vb (10)

26If PathName.Length > 0 AndAlso PathName.Chars(PathName.Length - 1) = Path.DirectorySeparatorChar Then 27DirName = Path.GetFullPath(PathName) 33FileName = Path.GetFileName(PathName) 34DirName = Path.GetDirectoryName(PathName) 42If Path.IsPathRooted(PathName) Then 43DirName = Path.GetPathRoot(PathName) 46If DirName.Chars(DirName.Length - 1) <> Path.DirectorySeparatorChar Then 47DirName = DirName & Path.DirectorySeparatorChar 51If DirName.Chars(DirName.Length - 1) <> Path.DirectorySeparatorChar Then 52DirName = DirName & Path.DirectorySeparatorChar

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

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

100Return GetDirectoryPath(IO.Path.GetTempPath(), SR.IO_SpecialDirectory_Temp)

Microsoft\VisualBasic\FileSystem.vb (7)

90IO.Directory.SetCurrentDirectory(Drive & Path.VolumeSeparatorChar) 123Dim CurrentPath As String = Path.GetFullPath(Drive & Path.VolumeSeparatorChar & ".") 366If Path.GetFileName(PathName).Length = 0 Then 386DirName = Path.GetDirectoryName(PathName) 392FileName = Path.GetFileName(PathName) 397DirName = DirName & Path.PathSeparator

Microsoft.VisualBasic.Forms (16)

Microsoft\VisualBasic\Helpers\FileSystemUtils.vb (2)

152''' <exception cref="Path.GetFullPath"> 153''' <see cref="Path.GetFullPath"/> for possible exceptions.

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

38Private _baseFileName As String = Path.GetFileNameWithoutExtension(Application.ExecutablePath) 137basePath = Path.GetDirectoryName(Application.ExecutablePath) 141basePath = Path.GetTempPath() 169Return Path.Join(basePath, fileName) 258Path.GetFullPath(value) 282Dim fileName As String = Path.GetFullPath(_customLocation) 288Dim tempPath As String = Path.GetFullPath(value) 594Debug.Assert(Not String.IsNullOrWhiteSpace(Path.GetDirectoryName(LogFileName)), "The log directory shouldn't be empty.") 595Dim fileName As String = Path.GetDirectoryName(LogFileName) 641Dim pathName As String = Path.GetPathRoot(Path.GetFullPath(FullLogFileName)) 667Dim baseStreamName As String = Path.GetFullPath($"{LogFileName}{FILE_EXTENSION}") 675fileName = Path.GetFullPath($"{LogFileName}{FILE_EXTENSION}") 677fileName = Path.GetFullPath(FormattableString.Invariant($"{LogFileName}-{i}{FILE_EXTENSION}"))

Microsoft.VisualBasic.Forms.Tests (20)

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

27Dim expectedBaseFileName As String = Path.GetFileNameWithoutExtension(Application.ExecutablePath) 48listener.FullLogFileName.Should.BeEquivalentTo(Path.Join(testDirectory, $"{expectedBaseFileName}.log")) 218fullLogFileName.Should.StartWith(Path.GetDirectoryName(Application.ExecutablePath)) 225If DirectoryIsAccessible(Path.GetDirectoryName(Application.ExecutablePath)) Then 260fullLogFileName.Should.StartWith(Path.GetTempPath)

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

181Dim expected As String = Path.GetTempPath.TrimEnd(Path.DirectorySeparatorChar) 182FileSystemUtils.NormalizePath(Path.GetTempPath).Should.Be(expected) 410temp &= Path.DirectorySeparatorChar 411temp.Should.Be(Path.GetTempPath)

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

15CreateTempDirectory().Should.StartWith(Path.GetTempPath) 28CreateTempFile(tempDirectory).Should.StartWith(Path.GetTempPath) 35Dim directoryPath As String = Path.Join(CreateTempDirectory(), GetUniqueFileName) 50testDirectory.Should.Be(Path.GetDirectoryName(testFile1))

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

12Private Shared ReadOnly s_baseTempPath As String = Path.Join(Path.GetTempPath, "DownLoadTest9d9e3a8-7a46-4333-a0eb-4faf76994801") 49Dim filenameWithPath As String = Path.Join(sourceDirectoryName, filename) 85Return Path.Join(testDirectory, GetUniqueFileName()) 99folder = Path.Join(BaseTempPath, $"{memberName}{lineNumber}") 101folder = Path.Join(BaseTempPath, memberName)

Microsoft.VisualBasic.IntegrationTests (2)

InteractionTests.cs (2)

107string path = Path.Join(Path.GetTempPath(), GetUniqueName());

Microsoft.VisualBasic.Tests (51)

Microsoft\VisualBasic\ApplicationServices\AssemblyInfoTests.cs (1)

24assemblyInfo.DirectoryPath.Should().Be(Path.GetDirectoryName(assembly.Location));

Microsoft\VisualBasic\Devices\AudioTests.cs (2)

52string location = Path.Join(Path.GetTempPath(), GetUniqueName());

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

Microsoft.VisualStudio.LanguageServices (55)

CommonControls\NewTypeDestinationSelectionViewModel.cs (2)

132if (!Path.GetExtension(trimmedFileName).Equals(_fileExtension, StringComparison.OrdinalIgnoreCase)) 138if (trimmedFileName.IndexOfAny(Path.GetInvalidFileNameChars()) >= 0)

EditAndContinue\EditAndContinueFeedbackDiagnosticFileProvider.cs (7)

62_tempDir = Path.GetTempPath(); 63var vsFeedbackTempDir = Path.Combine(_tempDir, VSFeedbackSemaphoreDir); 64_vsFeedbackSemaphoreFullPath = Path.Combine(vsFeedbackTempDir, VSFeedbackSemaphoreFileName); 94=> Path.Combine(Path.Combine(_tempDir, $"EnC_{_vsProcessId}", "Log")); 97=> Path.Combine(Path.Combine(_tempDir, $"EnC_{_vsProcessId}", ZipFileName));

GenerateType\GenerateTypeDialogViewModel.cs (2)

240if (trimmedFileName.IndexOfAny(Path.GetInvalidPathChars()) >= 0) 273this.FullFilePath = Path.GetFullPath(this.FullFilePath);

Implementation\AbstractEditorFactory.cs (3)

314projectToAddTo = AddEditorConfigFiles(projectToAddTo, Path.GetDirectoryName(filePath)); 385projectFolder = Path.GetDirectoryName(projectFolder); 397var editorConfigFile = Path.Combine(folder, EditorConfigFileName);

Interactive\VsResetInteractive.cs (2)

128var scriptsDir = Path.Combine(projectDir, "Scripts"); 129var outputDir = Path.Combine(projectDir, relativeOutputPath);

MoveStaticMembers\VisualStudioMoveStaticMembersOptionsService.cs (1)

65var newFileName = Path.ChangeExtension(typeName, language == LanguageNames.CSharp ? ".cs" : ".vb");

PdbSourceDocument\AbstractSourceLinkService.cs (1)

43Path.GetFileName(codeViewEntry.Path),

ProjectSystem\Legacy\AbstractLegacyProject.cs (6)

54private static readonly char[] PathSeparatorCharacters = [Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar]; 88_projectDirectory = Path.GetDirectoryName(projectFilePath); 212var linkFolderPath = Path.GetDirectoryName(linkMetadata); 274outputDirectory = FileUtilities.ResolveRelativePath(outputDirectory, Path.GetDirectoryName(ProjectSystemProject.FilePath)); 282ProjectSystemProject.OutputFilePath = FileUtilities.NormalizeAbsolutePath(Path.Combine(outputDirectory, targetFileName));

ProjectSystem\Legacy\AbstractLegacyProject_IAnalyzerHost.cs (1)

27ruleSetFileFullPath = Path.GetFullPath(ruleSetFileFullPath);

ProjectSystem\MetadataReferences\VisualStudioMetadataReferenceManager.cs (3)

139yield return Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86), @"Reference Assemblies\Microsoft\Framework\.NETFramework\v4.5"); 140yield return Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86), @"Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0"); 351assemblyDir ??= Path.GetDirectoryName(fullPath);

ProjectSystem\RuleSets\RuleSetEventHandler.cs (4)

92if (Path.GetExtension(oldFileFullPath).Equals(".ruleset", StringComparison.OrdinalIgnoreCase)) 171Path.GetExtension(fileFullPath).Equals(".ruleset", StringComparison.OrdinalIgnoreCase)) 191Path.GetExtension(fileFullPath).Equals(".ruleset", StringComparison.OrdinalIgnoreCase)) 226var projectDirectoryFullPath = Path.GetDirectoryName(project.FullName);

ProjectSystem\VisualStudioWorkspaceImpl.AddMetadataReferenceUndoUnit.cs (1)

59Path.GetFileName(_filePath));

ProjectSystem\VisualStudioWorkspaceImpl.cs (5)

973var baseName = Path.GetFileNameWithoutExtension(documentName); 974var extension = documentKind == TextDocumentKind.Document ? GetPreferredExtension(documentId) : Path.GetExtension(documentName); 976filePath = Path.Combine(folderPath, uniqueName); 1294Path.GetFileNameWithoutExtension(updatedInfo.Name), 1295Path.GetExtension(updatedInfo.Name));

ProjectSystem\VisualStudioWorkspaceImpl.RemoveMetadataReferenceUndoUnit.cs (1)

48Path.GetFileName(_filePath));

Snippets\SnippetExpansionClient.cs (1)

1084var existingReferenceNames = originalProject.MetadataReferences.Select(r => Path.GetFileNameWithoutExtension(r.Display));

Telemetry\FileLogger.cs (2)

39_logFilePath = Path.Combine(Path.GetTempPath(), "Roslyn", "Telemetry", GetLogFileName());

UnusedReferences\Dialog\UnusedReferencesTableProvider.DataSource.cs (2)

35var solutionName = Path.GetFileName(solution.FilePath); 128? Path.GetFileName(ReferenceUpdate.ReferenceInfo.ItemSpecification)

Watson\FaultReporter.cs (5)

Workspace\SourceGeneratedFileManager.cs (6)

94_temporaryDirectory = PathUtilities.EnsureTrailingSeparator(Path.Combine(Path.GetTempPath(), "VSGeneratedDocuments")); 120var temporaryFilePath = Path.Combine( 124document.HintName.Replace('/', Path.DirectorySeparatorChar)); 126Directory.CreateDirectory(Path.GetDirectoryName(temporaryFilePath)); 178var separatorIndex = slice.IndexOf(Path.DirectorySeparatorChar);

Microsoft.VisualStudio.LanguageServices.CSharp (5)

LanguageService\CSharpLanguageService_ICSharpProjectHost.cs (1)

19var projectName = Path.GetFileName(projectRoot.GetFullProjectName()); // GetFullProjectName returns the path to the project file w/o the extension?

ProjectSystemShim\CSharpProjectShim.ICSInputSet.cs (1)

53ProjectSystemProject.AssemblyName = Path.GetFileNameWithoutExtension(filename);

ProjectSystemShim\CSharpProjectShim.OptionsProcessor.cs (1)

191var directory = Path.GetDirectoryName(_projectSystemProject.FilePath);

ProjectSystemShim\TempPECompilerService.cs (2)

34var baseDirectory = Path.GetDirectoryName(pszOutputFileName); 55Path.GetFileName(pszOutputFileName),

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

PersistentStorage\AbstractPersistentStorageTests.cs (2)

873solution = solution.AddDocument(id, "file.cs", "class C { void M() }", filePath: Path.Combine(_persistentFolder.Path, "file.cs")); 893solution = solution.AddDocument(id, "file.cs", "class C { void M() }", filePath: Path.Combine(_persistentFolder.Path, "file.cs"));

ProjectSystemShim\CPS\AdditionalPropertiesTests.cs (3)

167Path.Combine(Path.GetDirectoryName(project.ProjectFilePath), "generated"), 170var path = Path.Combine(TempRoot.Root, "generated");

ProjectSystemShim\CPS\CSharpCompilerOptionsTests.cs (8)

94var expectedNewBinPath = Path.Combine(Path.GetTempPath(), newBinPath); 101var absoluteObjPath = Path.GetFullPath(Path.Combine(Path.GetTempPath(), relativeObjPath)); 198var path = Path.Combine(TempRoot.Root, "generated"); 206Path.Combine(Path.GetDirectoryName(cpsProject.ProjectFilePath), "gen2"),

ProjectSystemShim\CSharpHelpers.cs (5)

33var projectBinPath = Path.GetTempPath(); 56var projectFilePath = Path.GetTempPath(); 57var binOutputPath = GetOutputPathFromArguments(commandLineArguments) ?? Path.Combine(projectFilePath, projectName + ".dll"); 64var projectFilePath = Path.GetTempPath(); 136baseDirectory = Path.GetTempPath();

ProjectSystemShim\LegacyProject\SourceFileHandlingTests.cs (4)

66var projectFolder = Path.GetDirectoryName(environment.Workspace.CurrentSolution.Projects.Single().FilePath); 68project.AddFileEx(Path.Combine(projectFolder, "Cat.cs"), null); 80var projectFolder = Path.GetDirectoryName(environment.Workspace.CurrentSolution.Projects.Single().FilePath); 82project.AddFileEx(Path.Combine(projectFolder, "RelativeFolder", "Cat.cs"), null);

ProjectSystemShim\TempPECompilerServiceTests.cs (2)

31pszOutputFileName: Path.Combine(directory.Path, "Output.dll"), 37optionValues: [Path.Combine(directory.Path, "MissingReference.dll")]);

ProjectSystemShim\VisualStudioCompilationOutputFilesTests.cs (2)

74var outputs = new CompilationOutputFilesWithImplicitPdbPath(Path.Combine(dir.Path, "nonexistent.dll")); 89var debugDirPdbPath = Path.Combine(dir.Path, "nonexistent.pdb");

Microsoft.VisualStudio.LanguageServices.DevKit (1)

src\VisualStudio\Core\Def\PdbSourceDocument\AbstractSourceLinkService.cs (1)

43Path.GetFileName(codeViewEntry.Path),

Microsoft.VisualStudio.LanguageServices.LiveShare (7)

Client\Projects\RoslynRemoteProjectInfoProvider.cs (1)

95name: Path.GetFileNameWithoutExtension(path),

Client\RemoteLanguageServiceWorkspace.cs (6)

265return AddDocumentToProject(filePath, language, Path.GetFileName(Path.GetDirectoryName(remoteWorkspaceRoot))); 269return AddDocumentToProject(filePath, language, Path.GetFileName(Path.GetDirectoryName(remoteExternalRoot))); 336name: Path.GetFileName(filePath), 346var fileExtension = Path.GetExtension(filePath).ToLower();

Microsoft.VisualStudio.LanguageServices.Test.Utilities2 (9)

MockExtensionManager.vb (3)

35Return content.RelativePath.Replace("$RootFolder$", Path.Combine(TempRoot.Root, "ResolvedRootFolder")) 37Return content.RelativePath.Replace("$ShellFolder$", Path.Combine(TempRoot.Root, "ResolvedShellFolder")) 39Return Path.Combine(TempRoot.Root, "InstallPath", content.RelativePath)

ProjectSystemShim\Framework\TestEnvironment.vb (4)

149Directory.Delete(Path.GetDirectoryName(filePath)) 154Dim dir = Path.Combine(Path.GetTempPath, Guid.NewGuid().ToString("N")) 156Dim result = Path.Combine(dir, projectName + ".vbproj")

ProjectSystemShim\VisualBasicHelpers\MockCompilerHost.vb (1)

32Return Path.Combine(_sdkPath, fileName)

ProjectSystemShim\VisualBasicHelpers\VisualBasicHelpers.vb (1)

13Dim projectBinPath = Path.GetTempPath()

Microsoft.VisualStudio.LanguageServices.UnitTests (64)

CodeModel\CSharp\RootCodeModelTests.vb (4)

180Assert.Equal(Path.Combine(TestWorkspace.RootDirectory, "C.cs"), filePath) 217Assert.Equal(Path.Combine(TestWorkspace.RootDirectory, "C.g.cs"), filePath) 262Assert.Equal(Path.Combine(TestWorkspace.RootDirectory, "C.cs"), filePath) 307Assert.Equal(Path.Combine(TestWorkspace.RootDirectory, "C.cs"), filePath)

CodeModel\VisualBasic\RootCodeModelTests.vb (4)

115Assert.Equal(Path.Combine(TestWorkspace.RootDirectory, "C.vb"), filePath) 150Assert.Equal(Path.Combine(TestWorkspace.RootDirectory, "C.g.vb"), filePath) 191Assert.Equal(Path.Combine(TestWorkspace.RootDirectory, "C.vb"), filePath) 232Assert.Equal(Path.Combine(TestWorkspace.RootDirectory, "C.vb"), filePath)

Diagnostics\VisualStudioDiagnosticAnalyzerProviderTests.vb (6)

25Path.Combine(TempRoot.Root, "ResolvedRootFolder\test\test.dll"), 26Path.Combine(TempRoot.Root, "ResolvedShellFolder\test\test.dll"), 27Path.Combine(TempRoot.Root, "InstallPath\test\test.dll") 42Path.Combine(TempRoot.Root, "InstallPath\installPath1"), 43Path.Combine(TempRoot.Root, "InstallPath\installPath2"), 44Path.Combine(TempRoot.Root, "InstallPath\installPath3")

GenerateType\GenerateTypeViewModelTests.vb (3)

752Dim projectRootFolder = Path.GetTempPath() 755Dim randomFileName = Path.GetRandomFileName() 758Dim pathString = Path.Combine(projectRootFolder, randomFileName)

MoveStaticMembers\MoveStaticMembersViewModelTest.vb (2)

427Assert.Equal(Path.Combine(TestWorkspace.RootDirectory, "TestFile.cs"), options.FilePath) 867Assert.Equal(Path.Combine(TestWorkspace.RootDirectory, "TestFile.vb"), options.FilePath)

ProjectSystemShim\FileChangeWatcherTests.vb (2)

22_tempPath = Path.Combine(TempRoot.Root, Path.GetRandomFileName())

ProjectSystemShim\VisualStudioProjectTests\AnalyzerReferenceTests.vb (30)

ProjectSystemShim\VisualStudioRuleSetTests.vb (10)

ReferenceManager\VisualStudioMetadataReferenceManagerTests.vb (2)

19Dim assemblyDir = Path.GetDirectoryName(GetType(Object).Assembly.Location) 20Dim enterprisePath = Path.Combine(assemblyDir, "System.EnterpriseServices.dll")

SolutionExplorer\CpsDiagnosticItemSourceTests.vb (1)

47New MockHierarchyItem() With {.CanonicalName = Path.Combine(TestWorkspace.RootDirectory, "net472", "analyzerdependency") + "\" + analyzerPath},

Microsoft.VisualStudio.LanguageServices.VisualBasic (3)

ProjectSystemShim\TempPECompiler.TempPEProject.vb (1)

45Path.GetFileName(_outputPath),

ProjectSystemShim\VisualBasicProject.vb (2)

315ProjectSystemProject.AssemblyName = Path.GetFileNameWithoutExtension(pCompilerOptions.wszExeName) 322ProjectSystemProject.CompilationOutputAssemblyFilePath = Path.Combine(pCompilerOptions.wszOutputPath, pCompilerOptions.wszExeName)

Microsoft.Web.Xdt.Extensions.Tests (4)

InsertOrAppendAttributeTests.cs (4)

16var transform = new XmlTransformation(Path.GetFullPath("transform.xdt")); 40var transform = new XmlTransformation(Path.GetFullPath("transform.xdt")); 64var transform = new XmlTransformation(Path.GetFullPath("transform.xdt")); 88var transform = new XmlTransformation(Path.GetFullPath("transform.xdt"));

mscorlib (1)

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

338[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.IO.Path))]

Mvc.Analyzers.Test (1)

src\Shared\AnalyzerTesting\TestReferences.cs (1)

44var name = Path.GetFileNameWithoutExtension(assemblyPath);

Mvc.Api.Analyzers.Test (3)

Infrastructure\MvcDiagnosticAnalyzerRunner.cs (2)

37if (!project.MetadataReferences.Any(c => string.Equals(Path.GetFileNameWithoutExtension(c.Display), Path.GetFileNameWithoutExtension(assembly), StringComparison.OrdinalIgnoreCase)))

Infrastructure\MvcTestSource.cs (1)

15var filePath = Path.Combine(ProjectDirectory, "TestFiles", testClassName, testMethod + ".cs");

netstandard (1)

netstandard.cs (1)

948[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.IO.Path))]

NonDISample (1)

Program.cs (1)

13var keysFolder = Path.Combine(Directory.GetCurrentDirectory(), "temp-keys");

PrepareTests (40)

MinimizeUtil.cs (27)

22var duplicateDirectory = Path.Combine(destinationDirectory, duplicateDirectoryName); 33var outputPath = Path.Combine(destinationDirectory, individualFile); 34var outputDirectory = Path.GetDirectoryName(outputPath)!; 35CreateHardLink(outputPath, Path.Combine(sourceDirectory, individualFile)); 48var artifactsDir = Path.Combine(sourceDirectory, "artifacts/bin"); 51Path.Combine(sourceDirectory, "eng"), 52Path.Combine(sourceDirectory, "artifacts", "VSSetup"), 75var currentDirName = Path.GetDirectoryName(sourceFilePath)!; 76var currentRelativeDirectory = Path.GetRelativePath(sourceDirectory, currentDirName); 77var currentOutputDirectory = Path.Combine(destinationDirectory, currentRelativeDirectory); 83var fileName = Path.GetFileName(sourceFilePath); 90RelativePath: Path.Combine(currentRelativeDirectory, fileName), 96var destFilePath = Path.Combine(currentOutputDirectory, fileName); 114var destFilePath = Path.Combine(destinationDirectory, item.RelativePath); 122string getPeFilePath(Guid mvid) => Path.Combine(duplicateDirectory, getPeFileName(mvid)); 153rehydrateAllBuilder.AppendLine(@"bash """ + Path.Combine("$scriptroot", group.Key, "rehydrate.sh") + @""""); 158rehydrateAllBuilder.AppendLine("call " + Path.Combine("%~dp0", group.Key, "rehydrate.cmd")); 161File.WriteAllText(Path.Combine(destinationDirectory, group.Key, fileName), builder.ToString()); 173var file = Path.Combine(destinationDirectory, noDuplicate.Key, fileName); 180File.WriteAllText(Path.Combine(destinationDirectory, rehydrateAllFilename), rehydrateAllBuilder.ToString()); 189var destFileName = Path.GetRelativePath(group.Key, tuple.FilePath.RelativePath); 190if (Path.GetDirectoryName(destFileName) is { Length: not 0 } directory) 235var destFilePath = Path.GetRelativePath(group.Key, tuple.FilePath.RelativePath); 236if (Path.GetDirectoryName(destFilePath) is { Length: not 0 } directory) 261while (Path.GetFileName(Path.GetDirectoryName(groupDirectory)) is not (null or "Debug" or "Release")) 262groupDirectory = Path.GetDirectoryName(groupDirectory);

TestDiscovery.cs (13)

21var binDirectory = Path.Combine(repoRootDirectory, "artifacts", "bin"); 23var testDiscoveryWorkerFolder = Path.Combine(binDirectory, "TestDiscoveryWorker"); 60var dir = Path.GetDirectoryName(typeof(TestDiscovery).Assembly.Location); 61var tfm = Path.GetFileName(dir)!; 62var configuration = Path.GetFileName(Path.GetDirectoryName(dir))!; 69var testDiscoveryWorkerFolder = Path.Combine(binDirectory, "TestDiscoveryWorker"); 70return (Path.Combine(testDiscoveryWorkerFolder, configuration, tfm, "TestDiscoveryWorker.dll"), 71Path.Combine(testDiscoveryWorkerFolder, configuration, "net472", "TestDiscoveryWorker.exe")); 88var pathToOutput = Path.Combine(Path.GetDirectoryName(pathToAssembly)!, "testlist.json"); 118return Path.GetFileName(Path.GetDirectoryName(path)) != "net472";

PresentationBuildTasks (71)

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

139string currentProjectName = Path.GetFileNameWithoutExtension(CurrentProject); 140string currentProjectExtension = Path.GetExtension(CurrentProject); 149string randomFileName = Path.GetFileNameWithoutExtension(Path.GetRandomFileName()); 277( "_TargetAssemblyProjectName", Path.GetFileNameWithoutExtension(CurrentProject) ), 313foreach (FileInfo temporaryProjectFile in intermediateOutputPath.EnumerateFiles($"{Path.GetFileNameWithoutExtension(TemporaryTargetAssemblyProjectName)}*"))

Microsoft\Build\Tasks\Windows\MarkupCompilePass1.cs (10)

63_sourceDir = Directory.GetCurrentDirectory() + Path.DirectorySeparatorChar; 264if (!_outputDir.EndsWith(string.Empty + Path.DirectorySeparatorChar, StringComparison.Ordinal)) 266_outputDir += Path.DirectorySeparatorChar; 712string buildCodeFile = OutputPath + Path.ChangeExtension(relativeFilePath, buildExtension); 713string intelCodeFile = OutputPath + Path.ChangeExtension(relativeFilePath, intellisenseExtension); 721bamlFile = OutputPath + Path.ChangeExtension(relativeFilePath, SharedStrings.BamlExtension); 861return Path.Combine(OutputPath, fileName); 1077int pathEndIndex = fullFilePath.LastIndexOf(Path.DirectorySeparatorChar); 1125asmname = Path.GetFileNameWithoutExtension(refpath); 1672locFile = Path.ChangeExtension(xamlRelativeFilePath, SharedStrings.LocExtension);

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

49_sourceDir = Directory.GetCurrentDirectory() + Path.DirectorySeparatorChar; 243if (!_outputPath.EndsWith(string.Empty + Path.DirectorySeparatorChar, StringComparison.Ordinal)) 245_outputPath += Path.DirectorySeparatorChar; 540int pathEndIndex = fullFilePath.LastIndexOf(Path.DirectorySeparatorChar); 605asmname = Path.GetFileNameWithoutExtension(refpath); 774string bamlFileName = Path.ChangeExtension(resolvedXamlfile, SharedStrings.BamlExtension);

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

55string absoluteFilePath = Path.Combine(

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

38_sourcePath = Path.GetFullPath(path); 127SourceDir = Directory.GetCurrentDirectory() + Path.DirectorySeparatorChar; 252_outputPath = Path.GetFullPath(value); 254if (!_outputPath.EndsWith((Path.DirectorySeparatorChar).ToString(), StringComparison.Ordinal)) 255_outputPath += Path.DirectorySeparatorChar; 357string fullFilePath = Path.GetFullPath(filePath); 376relPath = Path.GetFileName(fullFilePath); 393Path.GetExtension(sourceFilePath).Equals(SharedStrings.BamlExtension) && 394Path.GetExtension(path).Equals(SharedStrings.XamlExtension)) 397path = Path.ChangeExtension(path, SharedStrings.BamlExtension);

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

155string sourceDir = Directory.GetCurrentDirectory() + Path.DirectorySeparatorChar; 358return Path.Combine(_backupPath, Path.ChangeExtension(Path.GetFileName(fileName), "uidtemp")); 363return Path.Combine(_backupPath, Path.ChangeExtension(Path.GetFileName(fileName), "uidbackup"));

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

472if (!TargetPath.EndsWith(string.Empty + Path.DirectorySeparatorChar, StringComparison.Ordinal)) 474TargetPath += Path.DirectorySeparatorChar; 478int pathEndIndex = SourceFileInfo.RelativeSourceFilePath.LastIndexOf(Path.DirectorySeparatorChar); 1599string pathOfRelativeSourceFilePath = System.IO.Path.GetDirectoryName(SourceFileInfo.RelativeSourceFilePath); 1606string path = Path.GetRelativePath(TargetPath + pathOfRelativeSourceFilePath, SourceFileInfo.SourcePath); 1609return path.TrimEnd(Path.DirectorySeparatorChar) + Path.DirectorySeparatorChar; 1618string[] dirs = relPath.Split(Path.DirectorySeparatorChar); 2648Directory.GetCurrentDirectory() + Path.DirectorySeparatorChar, 3340string fullFilePath = Path.GetFullPath(_splashImage); 3353relPath = TaskHelper.GetRootRelativePath(Directory.GetCurrentDirectory() + Path.DirectorySeparatorChar, fullFilePath); 3362resourceId = Path.GetFileName(fullFilePath);

MS\Internal\MarkupCompiler\PathInternal.cs (6)

42relativeTo = Path.GetFullPath(relativeTo); 43path = Path.GetFullPath(path); 89sb.Append(Path.DirectorySeparatorChar); 110sb.Append(Path.DirectorySeparatorChar); 125return c == Path.DirectorySeparatorChar || c == Path.AltDirectorySeparatorChar;

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

38_sourceDir = Directory.GetCurrentDirectory() + Path.DirectorySeparatorChar; 390if (!Path.IsPathRooted(filePath)) 396string fullFilePath = Path.GetFullPath(filePath); 419int pathEndIndex = fullFilePath.LastIndexOf(Path.DirectorySeparatorChar);

MS\Internal\Tasks\IncrementalCompileAnalyzer.cs (5)

208string filepath = Path.GetFullPath(fileName); 463Path.GetFullPath(taskItem.ItemSpec), 486string curDir = Directory.GetCurrentDirectory() + Path.DirectorySeparatorChar; 494string fullPath = Path.GetFullPath(_mcPass1.ContentFiles[i].ItemSpec); 500relContentFilePath = Path.GetFileName(fullPath);

MS\Internal\Tasks\TaskHelper.cs (3)

68if (!Path.IsPathRooted(thePath) ) 74thePath = Path.GetFullPath(thePath); 94string sourceDir = Directory.GetCurrentDirectory() + Path.DirectorySeparatorChar;

src\Microsoft.DotNet.Wpf\src\Shared\System\Windows\Markup\ReflectionHelper.cs (1)

564_cachedMetadataLoadContextAssembliesByNameNoExtension.Add(Path.GetFileNameWithoutExtension(fullPathToAssembly), assembly);

PresentationCore (21)

MS\Internal\FontCache\DWriteFactory.cs (3)

63localPath = Directory.GetParent(fontCollectionUri.LocalPath).FullName + Path.DirectorySeparatorChar; 71if (string.Equals((localPath.Length > 0 && localPath[localPath.Length - 1] != Path.DirectorySeparatorChar) ? localPath + Path.DirectorySeparatorChar : localPath, Util.WindowsFontsUriObject.LocalPath, StringComparison.OrdinalIgnoreCase))

MS\Internal\FontCache\FamilyCollection.cs (2)

45internal static string SxSFontsResourcePrefix { get; } = $"/{Path.GetFileNameWithoutExtension(ExternDll.PresentationCore)};component/fonts/"; 238FontSource fontSource = new FontSource(new Uri(Path.Combine(FamilyCollection.SxSFontsResourcePrefix, _systemCompositeFontsFileNames[index] + Util.CompositeFontExtension), UriKind.RelativeOrAbsolute),

MS\Internal\FontCache\FontCacheUtil.cs (2)

288private static readonly char[] InvalidFileNameChars = Path.GetInvalidFileNameChars(); 585return Path.GetExtension(unescapedPath);

MS\Internal\FontCache\FontResourceCache.cs (1)

126string extension = Path.GetExtension(fileName);

MS\Internal\FontCache\FontSourceCollection.cs (4)

74_isFileSystemFolder = localPath[localPath.Length - 1] == Path.DirectorySeparatorChar; 120if (Util.IsSupportedFontExtension(Path.GetExtension(file), out isComposite)) 144isComposite = Util.IsCompositeFont(Path.GetExtension(_uri.AbsoluteUri)); 149isComposite = Util.IsCompositeFont(Path.GetExtension(resourceName));

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

210String guid = Path.GetFileNameWithoutExtension(

src\Microsoft.DotNet.Wpf\src\Shared\MS\Internal\MimeTypeMapper.cs (1)

135string extensionWithDot = Path.GetExtension(docString);

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

97string folderPath = Path.GetTempPath(); 101string subFolderPath = Path.Combine(folderPath, subFolder); 115string path = Path.Combine(folderPath, Path.GetRandomFileName()); 118path = Path.ChangeExtension(path, extension);

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

217string filePath = Path.GetTempFileName();

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

567profilePath = new Uri(Path.Combine(buffer.ToString(), profilePathString));

PresentationCore.Tests (2)

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

61string tempFile = Path.GetTempFileName(); 87string tempFile = Path.GetTempFileName();

PresentationFramework (20)

Microsoft\Win32\FileDialog.cs (5)

112string safeFN = Path.GetFileName(CriticalItemName); 143safeFileNames[i] = Path.GetFileName(unsafeFileNames[i]); 458string tempPath = Path.GetFullPath(fileName); 564if (AddExtension && !Path.HasExtension(fileName)) 572string currentExtension = Path.GetExtension(fileName);

Microsoft\Win32\OpenFolderDialog.cs (2)

99string safeFN = Path.GetFileName(CriticalItemName); 130safeFolderNames[i] = Path.GetFileName(unsafeFolderNames[i]);

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

68_fullPath = System.IO.Path.Combine(System.IO.Path.GetDirectoryName(location), filePath);

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

116if (string.Equals(Path.GetExtension(_name), ResourceContainer.BamlExt, StringComparison.OrdinalIgnoreCase)) 121if (string.Equals(Path.GetExtension(_name), ResourceContainer.XamlExt, StringComparison.OrdinalIgnoreCase)) 124string newName = Path.ChangeExtension(_name, ResourceContainer.BamlExt);

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

600string extension = Path.GetExtension(path);

MS\Internal\WindowsRuntime\Generated\WinRT.cs (2)

100private static readonly string _currentModuleDirectory = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location); 123_moduleHandle = Platform.LoadLibraryExW(System.IO.Path.Combine(_currentModuleDirectory, fileName), IntPtr.Zero, /* LOAD_WITH_ALTERED_SEARCH_PATH */ 8);

MS\Win32\UxThemeWrapper.cs (1)

263themeName = Path.GetFileNameWithoutExtension(themeName);

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

1560tempFolder = System.IO.Path.GetTempPath();

System\Windows\Shell\JumpList.cs (2)

129itemPath = Path.GetFullPath(itemPath); 990return ShellUtil.GetShellItemForPath(Path.GetFullPath(jumpPath.Path));

System\Windows\SystemParameters.cs (1)

5533_uxThemeName = System.IO.Path.GetFileNameWithoutExtension(name);

PresentationUI (11)

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

98_filename = Path.GetFileName(_uri.LocalPath);

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

808file = Path.GetFileNameWithoutExtension(path); 819Path.GetDirectoryName(path), 820Path.DirectorySeparatorChar, 955if (!Path.GetExtension(location.LocalPath).Equals(

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

86Path.GetExtension(filePath),

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

365Path.GetFileNameWithoutExtension(DocumentProperties.Current.Filename),

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

860string msdrmdllPath = Path.Combine(systemPath, msdrmDLLName);

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

1356string applicationManifestFileLocation = Path.Combine( Path.GetDirectoryName(fileName),

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

1001return Path.GetFileNameWithoutExtension(_template.LocalPath);

ReachFramework (4)

Packaging\XpsFixedPageReaderWriter.cs (3)

1852ReadOnlySpan<char> extension = Path.GetExtension(path).Slice(1); 1897String extension = Path.GetExtension(path); 1898String fileName = Path.GetFileNameWithoutExtension(path);

Serialization\XpsFontSubsetter.cs (1)

657string fileName = System.IO.Path.GetFileNameWithoutExtension(

Replay (24)

Replay.cs (11)

59outputDirectory = Path.Combine(Path.GetTempPath(), "replay"); 83using var compilerServerLogger = new CompilerServerLogger("replay", Path.Combine(options.OutputDirectory, "server.log")); 199var outputDirectory = Path.Combine(options.OutputDirectory, outputName); 244if (Path.IsPathRooted(argValue)) 246fileName = Path.GetFileName(argValue); 255fileName = Path.Combine(hashSet.Count.ToString(), fileName); 258var filePath = Path.Combine(outputDirectory, fileName); 259Directory.CreateDirectory(Path.GetDirectoryName(filePath)!); 266var generatedDir = Path.Combine(outputDirectory, "generated"); 287internal string TempDirectory { get; } = Path.Combine(outputDirectory, "temp");

src\Compilers\Core\Portable\InternalUtilities\PlatformInformation.cs (2)

23public static bool IsWindows => Path.DirectorySeparatorChar == '\\'; 25public static bool IsUnix => Path.DirectorySeparatorChar == '/';

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

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

128loggingFilePath = Path.Combine(loggingFilePath, $"server.{processId}.log");

src\Compilers\Shared\NamedPipeUtil.cs (1)

36return Path.Combine("/tmp", pipeName);

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

63var filePath = Path.Combine(item, fileName);

src\Dependencies\Contracts\Contract.cs (1)

160var fileName = filePath is null ? null : Path.GetFileName(filePath);

ResultsOfTGenerator (2)

Program.cs (2)

17var classTargetFilePath = Path.Combine(pwd, "..", "..", "src", "ResultsOfT.Generated.cs"); 18var testsTargetFilePath = Path.Combine(pwd, "..", "..", "test", "ResultsOfTTests.Generated.cs");

Roslyn.Compilers.Extension (4)

CompilerPackage.cs (4)

37var packagePath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); 118var parentDirectory = new DirectoryInfo(Path.GetDirectoryName(fileAndContents.Key)); 176return Path.Combine(localAppData, $@"Microsoft\MSBuild\{version}"); 181return Path.Combine(await GetMSBuildPathAsync(cancellationToken).ConfigureAwait(true), relativePath);

Roslyn.Diagnostics.Analyzers (27)

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

src\Compilers\Core\Portable\FileSystem\PathUtilities.cs (4)

src\Compilers\Core\Portable\InternalUtilities\FileNameUtilities.cs (3)

src\Compilers\Core\Portable\InternalUtilities\PlatformInformation.cs (2)

23public static bool IsWindows => Path.DirectorySeparatorChar == '\\'; 25public static bool IsUnix => Path.DirectorySeparatorChar == '/';

src\Dependencies\Contracts\Contract.cs (1)

160var fileName = filePath is null ? null : Path.GetFileName(filePath);

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

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

15private static readonly char[] DirectorySeparatorCharacters = [Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar];

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EditorConfig\LanguageExtensions.cs (1)

16var fileExtension = Path.GetExtension(filePath);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EditorConfig\Parsing\Sections\Section.cs (1)

39var containingDirectory = Path.GetDirectoryName(FilePath);

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

61var thisAssemblyFolder = Path.GetDirectoryName(thisAssemblyName); 63? Path.Combine(thisAssemblyFolder, assemblySimpleName + ".dll")

Roslyn.Test.Performance.Utilities (36)

Benchview.cs (15)

18private static readonly string s_scriptDirectory = Path.Combine( 81var consumptionXml = Path.Combine(GetCPCDirectoryPath(), "consumptionTempResults.xml"); 87var consumptionXml = Path.Combine(GetCPCDirectoryPath(), "consumptionTempResults.xml"); 92var submissionJson = CreateSubmissionJson(s_submissionType, submissionName, s_branch, Path.Combine(s_outputDirectory, "measurement.json")); 95var uploadPy = Path.Combine(s_scriptDirectory, "upload.py"); 115var measurementPy = Path.Combine(s_scriptDirectory, "measurement.py"); 116var measurementJson = Path.Combine(s_outputDirectory, "measurement.json"); 127var submissionMetadataPy = Path.Combine(s_scriptDirectory, "submission-metadata.py"); 128var buildPy = Path.Combine(s_scriptDirectory, "build.py"); 129var machinedataPy = Path.Combine(s_scriptDirectory, "machinedata.py"); 130var submissionPy = Path.Combine(s_scriptDirectory, "submission.py"); 132var submissionMetadataJson = Path.Combine(s_outputDirectory, "submission-metadata.json"); 133var buildJson = Path.Combine(s_outputDirectory, "build.json"); 134var machinedataJson = Path.Combine(s_outputDirectory, "machinedata.json"); 153string submissionJson = Path.Combine(s_outputDirectory, "submission.json");

Logger.cs (1)

48_file = Path.Combine(TestUtilities.GetCPCDirectoryPath(), "perf-log.txt");

RelativeDirectory.cs (2)

93public string TaoPath => Path.Combine(MyBinaries(), "exes", "EditorTestApp", "Tao"); 104var zipPath = Path.Combine(TempDirectory, zipFileName);

ScenarioGenerator.cs (1)

21_fullPath = Path.Combine(TestUtilities.GetCPCDirectoryPath(), "scenarios.xml");

TestUtilities.cs (1)

54return Path.Combine(GetCPCDirectoryPath(), "ViBenchToJson.exe");

TraceManager.cs (3)

19var cpcFullPath = Path.Combine(TestUtilities.GetCPCDirectoryPath(), "CPC.exe"); 66var scenariosXmlPath = Path.Combine(GetCPCDirectoryPath(), "scenarios.xml"); 67var consumptionTempResultsPath = Path.Combine(GetCPCDirectoryPath(), "ConsumptionTempResults.xml");

VsPerfTest.cs (13)

25Path.Combine(System.Environment.GetEnvironmentVariable("UserProfile"), ".nuget", "packages"); 26private static readonly string _installerPath = Path.Combine(_nugetPackagesPath, "roslyntools.vsixexpinstaller", "1.0.0-beta2-63222-01", "tools", "vsixexpinstaller.exe"); 50var dir = Path.Combine(Path.GetDirectoryName(MyWorkingDirectory), "csharp"); 54var logDirectory = Path.Combine(TempDirectory, _testName); 56Directory.CreateDirectory(Path.Combine(logDirectory, "PerfResults")); 59var taoTestFileTemplatePath = Path.Combine(dir, _testTemplateName); 61var finalTest = template.Replace("ReplaceWithActualSolutionPath", Path.Combine(TempDirectory, _zipFileToDownload, _solutionToTest)); 68File.WriteAllText(Path.Combine(TempDirectory, _testTemplateName), finalTest); 79var vsix = Path.Combine(MyBinaries(), "Vsix", "VisualStudioSetup", "Roslyn.VisualStudio.Setup.vsix"); 92var args = $"{Path.Combine(TempDirectory, _testTemplateName)} -perf -host:vs -roslynonly -rootsuffix:{_rootSuffix}"; 95var logDirectory = Path.Combine(TempDirectory, _testName, "PerfResults"); 96var xcopyArgs = $"{logDirectory} {Path.Combine(MyBinaries(), "..", "..", "ToArchive")} /s /i /y";

Roslyn.VisualStudio.Next.UnitTests (24)

Options\VisualStudioOptionStorageTests.cs (11)

Remote\RemoteHostClientServiceFactoryTests.cs (1)

80(service, cancellationToken) => service.UpdateContinuouslyAsync("emptySource", Path.GetTempPath(), cancellationToken),

Remote\SnapshotSerializationTests.cs (7)

59.AddAnalyzerReference(new AnalyzerFileReference(Path.Combine(TempRoot.Root, "path1"), new TestAnalyzerAssemblyLoader())) 63.WithAnalyzerReferences([new AnalyzerFileReference(Path.Combine(TempRoot.Root, "path2"), new TestAnalyzerAssemblyLoader())]) 392var reference = new AnalyzerFileReference(Path.Combine(TempRoot.Root, "missing_reference"), new MissingAnalyzerLoader()); 406var reference = new AnalyzerFileReference(Path.Combine(TempRoot.Root, "missing_reference"), new MissingAnalyzerLoader()); 504var analyzer = new AnalyzerFileReference(Path.Combine(TempRoot.Root, "missing_reference"), new MissingAnalyzerLoader()); 538var analyzer = serializer.CreateChecksum(new AnalyzerFileReference(Path.Combine(TempRoot.Root, "missing"), new MissingAnalyzerLoader()), CancellationToken.None); 567var tempCorlibXml = tempDir.CreateFile(Path.ChangeExtension(tempCorlib.Path, "xml"));

Services\ServiceHubServicesTests.cs (2)

448assemblyPath: Path.Combine(TempRoot.Root, "Test.dll"), 771assemblyPath: Path.Combine(TempRoot.Root, "Test.dll"),

Services\SolutionServiceTests.cs (3)

247var dir = Path.GetDirectoryName(typeof(SolutionServiceTests).Assembly.Location); 349var configPath = Path.Combine(Path.GetTempPath(), ".editorconfig");

RulesetToEditorconfigConverter (4)

Program.cs (1)

18Path.Combine(Environment.CurrentDirectory, ".editorconfig");

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

RulesetToEditorconfigConverter.UnitTests (6)

RulesetToEditorconfigConverterTests.cs (6)

18var directory = Directory.CreateDirectory(Path.Combine(Path.GetTempPath(), Path.GetRandomFileName())); 22var ruleset = Path.Combine(directory.FullName, PrimaryRulesetName); 28var includedRuleset = Path.Combine(directory.FullName, IncludedRulesetName); 32var editorconfigPath = Path.Combine(directory.FullName, ".editorconfig");

RunTests (49)

AssemblyInfo.cs (1)

13public string AssemblyName => Path.GetFileName(AssemblyPath);

AssemblyScheduler.cs (3)

46ConsoleUtil.WriteLine($"\tAssembly: {Path.GetFileName(kvp.Key)}, Test Type Count: {typeCount}, Test Count: {testCount}"); 250var assemblyDirectory = Path.GetDirectoryName(assemblyFilePath); 251var testListPath = Path.Combine(assemblyDirectory!, "testlist.json");

HelixTestRunner.cs (23)

65var payloadsDir = Path.Combine(options.ArtifactsDirectory, "payloads"); 66var logsDir = Path.Combine(options.ArtifactsDirectory, "log", options.Configuration); 80var helixFilePath = Path.Combine(options.ArtifactsDirectory, "helix.proj"); 83var arguments = $"build -bl:{Path.Combine(logsDir, "helix.binlog")} {helixFilePath}"; 98File.Copy(helixFilePath, Path.Combine(logsDir, "helix.proj")); 150var duplicateDir = Path.Combine(Path.GetDirectoryName(artifactsDir)!, ".duplicate"); 196var workItemPayloadDir = Path.Combine(payloadsDir, helixWorkItem.DisplayName); 199var binDir = Path.Combine(artifactsDir, "bin"); 201.Select(x => Path.GetRelativePath(binDir, x)) 206var name = Path.GetDirectoryName(assemblyRelativePath)!; 207var targetDir = Path.Combine(workItemPayloadDir, name); 208var sourceDir = Path.Combine(binDir, name); 209_ = Directory.CreateDirectory(Path.GetDirectoryName(targetDir)!); 215Path.Combine(workItemPayloadDir, rspFileName), 219File.WriteAllText(Path.Combine(workItemPayloadDir, commandFileName), commandContent); 222File.WriteAllText(Path.Combine(workItemPayloadDir, postCommandFileName), postCommandContent); 288var directoryName = Path.GetDirectoryName(assemblyRelativeFilePath); 390var globalJsonPath = Path.Join(path, "global.json"); 395path = Path.GetDirectoryName(path); 472var relativePath = Path.GetRelativePath(payloadsDir, filePath); 473var destinationPath = Path.Combine(logsDir, relativePath); 474_ = Directory.CreateDirectory(Path.GetDirectoryName(destinationPath)!);

Options.cs (6)

217: Path.Combine(artifactsPath, "TestResults", configuration); 264while (path is object && Path.GetFileName(path) != "artifacts") 266path = Path.GetDirectoryName(path); 277while (dir != null && !File.Exists(Path.Combine(dir, programName))) 279dir = Path.GetDirectoryName(dir); 282return dir == null ? null : Path.Combine(dir, programName);

ProcessTestExecutor.cs (6)

97var dotnetDir = Path.GetDirectoryName(dotnetPath)!; 98var sdkDir = Path.Combine(dotnetDir, "sdk"); 106return Path.Combine(options.TestResultsDirectory, fileName); 116var rspFilePath = Path.Combine(getRspDirectory(), $"vstest_{workItemInfo.PartitionIndex}.rsp"); 123var resultsDir = Path.GetDirectoryName(resultsFilePath); 205var dirPath = Path.Combine(options.ArtifactsDirectory, "tmp", options.Configuration, "vstest-rsp");

Program.cs (8)

198var logFilePath = Path.Combine(options.LogFilesDirectory, "runtests.log"); 264var screenshotPath = Path.Combine(options.LogFilesDirectory, $"timeout.png"); 279var dumpFilePath = Path.Combine(dumpDir, $"{proc.ProcessName}-{counter}.dmp"); 291var binDirectory = Path.Combine(options.ArtifactsDirectory, "bin"); 294var name = Path.GetFileName(project); 303var configDirectory = Path.Combine(project, options.Configuration); 312var tfm = Path.GetFileName(targetFrameworkDirectory)!; 319var filePath = Path.Combine(targetFrameworkDirectory, fileName);

TestRunner.cs (2)

23var assembliesString = string.Join("_", Filters.Keys.Select(a => Path.GetFileNameWithoutExtension(a.AssemblyName))); 200var outputLogPath = Path.Combine(_options.LogFilesDirectory, $"xUnitFailure-{testResult.DisplayName}.log");

SemanticSearch.BuildTask (5)

GenerateFilteredReferenceAssembliesTask.cs (4)

95var referencesByName = References.ToDictionary(r => Path.GetFileNameWithoutExtension(r.ItemSpec), r => r.ItemSpec); 99var assemblyName = Path.GetFileNameWithoutExtension(specPath); 106var filteredReferencePath = Path.Combine(OutputDir, assemblyName + ".dll"); 137string outputFilePath = Path.Combine(ApisDir, assemblyName + ".txt");

src\Dependencies\Contracts\Contract.cs (1)

160var fileName = filePath is null ? null : Path.GetFileName(filePath);

ServerComparison.FunctionalTests (4)

Helpers.cs (4)

19var solutionFileInfo = new FileInfo(Path.Combine(directoryInfo.FullName, "FunctionalTests.slnf")); 22return Path.GetFullPath(Path.Combine(directoryInfo.FullName, "..", "..", "testassets", "ServerComparison.TestSites")); 35var content = File.ReadAllText(Path.Combine(applicationBasePath, nginxConfig));

SignalR.Client.FunctionalTestApp (4)

src\SignalR\common\Shared\TestCertificates.cs (4)

Sockets.BindTests (3)

src\Shared\TestResources.cs (3)

Sockets.FunctionalTests (5)

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

38var path = Path.GetTempFileName(); 136var path = Path.GetTempFileName();

src\Shared\TestResources.cs (3)

StaticFilesAuth (8)

Startup.cs (8)

30var basePath = Path.Combine(HostingEnvironment.ContentRootPath, "PrivateFiles"); 31var usersPath = Path.Combine(basePath, "Users"); 47var userPath = Path.Combine(usersPath, userName); 55|| directory.FullName.StartsWith(userPath + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase); 86var files = new PhysicalFileProvider(Path.Combine(env.ContentRootPath, "PrivateFiles")); 128new DirectoryInfo(Path.GetDirectoryName(fileSystemPath)), 146return Path.Join(files.Root, path); 154return Path.Join(files.Root, path);

Stress.ApiService (2)

Program.cs (2)

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

Swaggatherer (3)

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

System.CodeDom (5)

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

132_basePath = Path.Combine( 134Path.GetFileNameWithoutExtension(Path.GetRandomFileName())); 221Directory.Delete(Path.GetDirectoryName(BasePath));

System\CodeDom\Compiler\CodeValidator.cs (1)

944if (e.FileName.IndexOfAny(Path.GetInvalidPathChars()) != -1)

System.ComponentModel.Annotations (1)

System\ComponentModel\DataAnnotations\FileExtensionsAttribute.cs (1)

50return ExtensionsParsed.Contains(Path.GetExtension(fileName).ToLowerInvariant());

System.ComponentModel.Composition (3)

System\ComponentModel\Composition\Hosting\ApplicationCatalog.cs (1)

90var path = Path.Combine(location, probingPath);

System\ComponentModel\Composition\Hosting\DirectoryCatalog.cs (2)

17using IOPath = System.IO.Path; 741var fullPath = IOPath.GetFullPath(path);

System.ComponentModel.TypeConverter (3)

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

98string fileName = Path.GetFileName(location);

System\ComponentModel\LicFileLicenseProvider.cs (1)

81string? moduleDir = Path.GetDirectoryName(modulePath);

System\ComponentModel\SyntaxCheck.cs (1)

60return Path.IsPathRooted(value);

System.Configuration.ConfigurationManager (41)

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

132_basePath = Path.Combine( 134Path.GetFileNameWithoutExtension(Path.GetRandomFileName())); 221Directory.Delete(Path.GetDirectoryName(BasePath));

System\Configuration\AppSettingsSection.cs (2)

102: Path.Combine(Path.GetDirectoryName(configFile), File);

System\Configuration\BaseConfigurationRecord.cs (1)

3205if (string.IsNullOrEmpty(configSource) || Path.IsPathRooted(configSource))

System\Configuration\ClientConfigPaths.cs (11)

46ApplicationUri = Path.GetFullPath(exePath); 67ApplicationUri = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, exeAssembly.ManifestModule.Name); 100if (!Path.IsPathRooted(externalConfigPath)) 102externalConfigPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, externalConfigPath); 105ApplicationConfigUri = Path.GetFullPath(externalConfigPath); 116Path.ChangeExtension(ApplicationUri, ".dll") : ApplicationUri + ".dll"; 156if (Path.IsPathRooted(roamingFolderPath)) 163if (Path.IsPathRooted(localFolderPath)) 226return Path.Combine(path1, path2); 263else if (Uri.TryCreate(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, assembly.ManifestModule.Name), UriKind.Absolute, out Uri codeBase)) 379foreach (char c in Path.GetInvalidFileNameChars()) validated = validated.Replace(c, '_');

System\Configuration\ClientConfigurationHost.cs (6)

49s_machineConfigFilePath = Path.Combine(Path.Combine(directory, MachineConfigSubdirectory), 154_fileMap.MachineConfigFilename = Path.GetFullPath(fileMap.MachineConfigFilename); 160_fileMap.ExeConfigFilename = Path.GetFullPath(exeFileMap.ExeConfigFilename); 163_fileMap.RoamingUserConfigFilename = Path.GetFullPath(exeFileMap.RoamingUserConfigFilename); 166_fileMap.LocalUserConfigFilename = Path.GetFullPath(exeFileMap.LocalUserConfigFilename);

System\Configuration\Configuration.cs (1)

213filename = string.IsNullOrEmpty(filename) ? null : Path.GetFullPath(filename);

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

194if (!Path.IsPathRooted(streamName)) throw ExceptionUtil.ParameterInvalid(nameof(streamName)); 197streamName = Path.GetFullPath(streamName); 201string result = Path.Combine(dirStream, configSource); 202result = Path.GetFullPath(result); 241string dir = Path.GetDirectoryName(streamName); 298return Path.IsPathRooted(streamName);

System\Configuration\LocalFileSettingsProvider.cs (1)

327file = Path.Combine(previousDirectory.FullName, ConfigurationManagerInternalFactory.Instance.UserConfigFilename);

System\Configuration\NameValueFileSectionHandler.cs (2)

40string directory = Path.GetDirectoryName(configFile); 41string sourceFileFullPath = Path.Combine(directory, filename);

System\Configuration\UrlPath.cs (2)

15return Path.GetDirectoryName(path) ?? Path.GetPathRoot(path);

System\Diagnostics\TraceUtils.cs (5)

74if ((initializeData[0] != Path.DirectorySeparatorChar) && (initializeData[0] != Path.AltDirectorySeparatorChar) && !Path.IsPathRooted(initializeData)) 80string dirPath = Path.GetDirectoryName(filePath); 83initializeData = Path.Combine(dirPath, initializeData);

System.Data.Common (3)

System\Data\xmlsaver.cs (3)

1094_filePath = Path.GetDirectoryName(fs.Name); 1095_fileName = Path.GetFileNameWithoutExtension(fs.Name); 1096_fileExt = Path.GetExtension(fs.Name);

System.Data.Odbc (1)

Common\System\Data\Common\AdapterUtil.Odbc.cs (1)

651return Path.GetFullPath(filename);

System.Diagnostics.TextWriterTraceListener (4)

System\Diagnostics\TextWriterTraceListener.cs (4)

227string fullPath = Path.GetFullPath(_fileName); 228string dirPath = Path.GetDirectoryName(fullPath)!; 229string fileNameOnly = Path.GetFileName(fullPath); 242fullPath = Path.Combine(dirPath, fileNameOnly);

System.Drawing.Common.Tests (19)

Helpers.cs (1)

69private static string GetTestPath(string directoryName, string fileName) => Path.Join(AppContext.BaseDirectory, directoryName, fileName);

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

297sRslt = Path.GetFullPath(sSub); 780string filename = Path.GetTempFileName();

System\Drawing\IconConverterTests.cs (1)

21_icon = new Icon(Path.Join("bitmaps", "TestIcon.ico"));

System\Drawing\IconTests.cs (3)

358string bitmapPathRoot = Path.GetPathRoot(bitmapPath); 812Icon.ExtractIcon(Path.GetRandomFileName() + ".ico", 0, 16); 817Icon.ExtractIcon(Path.GetRandomFileName() + ".ico", 0);

System\Drawing\ImageAnimator.ManualTests.cs (4)

10public static string OutputFolder { get; } = Path.Join(Environment.CurrentDirectory, "ImageAnimatorManualTests", DateTime.Now.ToString("yyyy-MM-dd-HH-mm-ss")); 47string testOutputFolder = Path.Join(OutputFolder, Path.GetFileNameWithoutExtension(imageName)); 60animation.Save(Path.Join(testOutputFolder, $"{++frameIndexes[imageName]}_{timestamp}.jpg"), ImageFormat.Jpeg);

System\Drawing\ImageConverterTests.cs (2)

19_image = Image.FromFile(Path.Join("bitmaps", "TestImage.bmp")); 49string path = Path.Join("bitmaps", "TestImageWithOleHeader.bmp");

System\Drawing\ImageTests.cs (1)

665string badTarget = Path.Join("NoSuchDirectory", "NoSuchFile");

System\Drawing\Imaging\ImageFormatTests.cs (4)

74yield return new object[] { Path.Join("bitmaps", "nature24bits.gif"), "Gif" }; 75yield return new object[] { Path.Join("bitmaps", "nature24bits.jpg"), "Jpeg" }; 76yield return new object[] { Path.Join("bitmaps", "VisualPng.ico"), "Icon" }; 77yield return new object[] { Path.Join("bitmaps", "almogaver32bits.tif"), "Tiff" };

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

44string relativePath = Path.Join("fonts", "CodeNewRoman.ttf");

System.Formats.Tar (47)

src\libraries\Common\src\Interop\Unix\Interop.IOErrors.cs (2)

172string? parentPath = Path.GetDirectoryName(Path.TrimEndingDirectorySeparator(fullPath));

src\libraries\Common\src\System\IO\PathInternal.cs (2)

246Path.Join(Path.GetDirectoryName(path.AsSpan()), pathToTarget.AsSpan()) : pathToTarget;

src\libraries\Common\src\System\IO\PathInternal.Unix.cs (1)

81return !Path.IsPathRooted(path);

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

315TarHelpers.CreateDirectory(Path.GetDirectoryName(destinationFullPath)!, mode: null, pendingModes); 339TarHelpers.CreateDirectory(Path.GetDirectoryName(destinationFullPath)!, mode: null, pendingModes); 348Debug.Assert(Path.IsPathFullyQualified(destinationDirectoryPath)); 353Path.IsPathFullyQualified(name) ? name : Path.Join(destinationDirectoryPath, name)); 367Path.IsPathFullyQualified(linkName) ? linkName : Path.Join(Path.GetDirectoryName(fileDestinationPath), linkName)); 382Path.Join(destinationDirectoryPath, linkName)); 397Debug.Assert(Path.IsPathFullyQualified(qualifiedPath), $"{qualifiedPath} is not qualified"); 400string fullPath = Path.GetFullPath(qualifiedPath); // Removes relative segments 450Debug.Assert(Directory.Exists(Path.GetDirectoryName(filePath))); 505string? directoryPath = Path.GetDirectoryName(filePath); 507if (!string.IsNullOrEmpty(directoryPath) && !Path.Exists(directoryPath)) 512if (!Path.Exists(filePath)) 535Debug.Assert(!Path.Exists(destinationFileName)); 551Debug.Assert(!Path.Exists(destinationFileName));

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

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

1195ReadOnlySpan<char> dirName = Path.GetDirectoryName(_name.AsSpan()); 1198ReadOnlySpan<char> fileName = Path.GetFileName(_name.AsSpan()); 1202$"{dirName}/PaxHeaders.{Environment.ProcessId}/{fileName}{Path.DirectorySeparatorChar}" : 1217ReadOnlySpan<char> tmp = Path.TrimEndingDirectorySeparator(Path.GetTempPath());

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

469=> c == Path.DirectorySeparatorChar;

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

25string filename = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());

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

388string fullPath = Path.GetFullPath(fileName); 389string? actualEntryName = string.IsNullOrEmpty(entryName) ? Path.GetFileName(fileName) : entryName;

System.IO.Compression.ZipFile (12)

src\libraries\Common\src\Interop\Unix\Interop.IOErrors.cs (2)

172string? parentPath = Path.GetDirectoryName(Path.TrimEndingDirectorySeparator(fullPath));

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

483sourceDirectoryName = Path.GetFullPath(sourceDirectoryName); 484destinationArchiveFileName = Path.GetFullPath(destinationArchiveFileName); 503return Path.GetFullPath(sourceDirectoryName);

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

95Directory.CreateDirectory(Path.GetDirectoryName(fileDestinationPath)!);

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

116if (!destinationDirectoryFullPath.EndsWith(Path.DirectorySeparatorChar)) 118char sep = Path.DirectorySeparatorChar; 122fileDestinationPath = Path.GetFullPath(Path.Combine(destinationDirectoryFullPath, ArchivingUtils.SanitizeEntryFilePath(source.FullName))); 127if (Path.GetFileName(fileDestinationPath).Length == 0) 146Directory.CreateDirectory(Path.GetDirectoryName(fileDestinationPath)!);

System.IO.FileSystem.Watcher (10)

src\libraries\Common\src\Interop\Unix\Interop.IOErrors.cs (2)

172string? parentPath = Path.GetDirectoryName(Path.TrimEndingDirectorySeparator(fullPath));

src\libraries\Common\src\System\IO\PathInternal.cs (2)

246Path.Join(Path.GetDirectoryName(path.AsSpan()), pathToTarget.AsSpan()) : pathToTarget;

src\libraries\Common\src\System\IO\PathInternal.Unix.cs (1)

81return !Path.IsPathRooted(path);

System\IO\FileSystemWatcher.cs (1)

376ReadOnlySpan<char> name = IO.Path.GetFileName(relativePath);

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

468AddDirectoryWatchUnlocked(directoryEntry, System.IO.Path.GetFileName(subDir)); 987if (c != System.IO.Path.DirectorySeparatorChar && c != System.IO.Path.AltDirectorySeparatorChar) 989builder.Append(System.IO.Path.DirectorySeparatorChar);

System.IO.IsolatedStorage (18)

System\IO\IsolatedStorage\Helper.cs (2)

71if (Path.GetFileName(directory)?.Length == 12) 75if (Path.GetFileName(subdirectory)?.Length == 12)

System\IO\IsolatedStorage\Helper.NonMobile.cs (4)

26dataDirectory = Path.Combine(dataDirectory, IsolatedStorageDirectoryName); 49randomDirectory = Path.Combine(rootDirectory, Path.GetRandomFileName(), Path.GetRandomFileName());

System\IO\IsolatedStorage\IsolatedStorage.cs (1)

115get { return Path.DirectorySeparatorChar; }

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

177return Directory.EnumerateFiles(RootDirectory, searchPattern).Select(f => Path.GetFileName(f)).ToArray(); 201return Directory.EnumerateDirectories(RootDirectory, searchPattern).Select(m => m.Substring(Path.GetDirectoryName(m)!.Length + 1)).ToArray(); 548if (partialPath[i] != Path.DirectorySeparatorChar && partialPath[i] != Path.AltDirectorySeparatorChar) 556return Path.Combine(RootDirectory, partialPath); 627parentDirectory = Path.GetDirectoryName(parentDirectory); 716private static bool IsIdFile(string file) => string.Equals(Path.GetFileName(file), "identity.dat"); 718private static bool IsInfoFile(string file) => string.Equals(Path.GetFileName(file), "info.dat");

System\IO\IsolatedStorage\IsolatedStorageFile.NonMobile.cs (3)

64string directoryName = Path.GetFileName(directory); 74return Path.GetDirectoryName(RootDirectory.TrimEnd(Path.DirectorySeparatorChar));

System.IO.Packaging (6)

System\IO\Packaging\PackUriHelper.cs (6)

206string file = Path.GetFileName(partName); 214partName = Path.Combine(partName, RelationshipPartSegmentName, file); // Adding the "_rels" segment and the last segment back 262string partNameWithoutExtension = Path.GetFileNameWithoutExtension(path); 274path = Path.Combine(path, partNameWithoutExtension); // Adding the last segment without ".rels" extension 679string partUriExtension = Path.GetExtension(_partUriString); 786Debug.Assert(Path.GetExtension(segments[segments.Length - 1]) == RelationshipPartUpperCaseExtension);

System.IO.Ports (2)

src\libraries\Common\src\Interop\Unix\Interop.IOErrors.cs (2)

172string? parentPath = Path.GetDirectoryName(Path.TrimEndingDirectorySeparator(fullPath));

System.Net.Mail (5)

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

296Name = Path.GetFileName(fileName); 303Name = Path.GetFileName(fileName); 312Name = Path.GetFileName(fileName);

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

364if (!Path.IsPathRooted(pickupDirectory)) 371pathAndFilename = Path.Combine(pickupDirectory, filename);

System.Net.Ping (2)

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

30string pathv4v6 = Path.Combine(folder, s_ipv4v6PingFile); 31string path = Path.Combine(folder, fileName);

System.Net.WebClient (4)

System\Net\WebClient.cs (4)

478fileName = Path.GetFullPath(fileName); 507"Content-Disposition: form-data; name=\"file\"; filename=\"" + Path.GetFileName(fileName) + "\"\r\n" + // TODO: Should the filename path be encoded? 787return new Uri(Path.GetFullPath(address)); 792return new Uri(Path.GetFullPath(address));

System.Private.CoreLib (148)

src\libraries\Common\src\Interop\Unix\Interop.IOErrors.cs (2)

172string? parentPath = Path.GetDirectoryName(Path.TrimEndingDirectorySeparator(fullPath));

src\libraries\Common\src\System\IO\PathInternal.cs (2)

246Path.Join(Path.GetDirectoryName(path.AsSpan()), pathToTarget.AsSpan()) : pathToTarget;

src\libraries\Common\src\System\IO\PathInternal.Unix.cs (1)

81return !Path.IsPathRooted(path);

src\libraries\System.Private.CoreLib\src\System\AppContext.AnyOS.cs (2)

27string? directory = Path.GetDirectoryName(path); 32if (!Path.EndsInDirectorySeparator(directory))

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

122string fullPath = Path.GetFullPath(assemblyFile);

src\libraries\System.Private.CoreLib\src\System\Environment.GetFolderPathCore.Unix.cs (6)

130data = Path.Combine(home, ".local", "share"); 142return Path.Combine(home, ".fonts"); 157config = Path.Combine(home, ".config"); 181string userDirsPath = Path.Combine(GetXdgConfig(homeDir), "user-dirs.dirs"); 233Path.Join(homeDir, line.AsSpan(pos, endPos - pos)) : 245return Path.Combine(homeDir, fallback);

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

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

20string fullPath = Path.GetFullPath(path); 31string tempPath = Path.GetTempPath();

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

20fullPath: Path.GetFullPath(path), 34fullPath = isNormalized ? fullPath : Path.GetFullPath(fullPath); 53Path.GetFileName(Path.TrimEndingDirectorySeparator(fullPath))).ToString(); 67string? parentName = Path.GetDirectoryName(PathInternal.IsRoot(FullPath.AsSpan()) ? FullPath : Path.TrimEndingDirectorySeparator(FullPath)); 80if (Path.IsPathRooted(path)) 83string newPath = Path.GetFullPath(Path.Combine(FullPath, path)); 85ReadOnlySpan<char> trimmedNewPath = Path.TrimEndingDirectorySeparator(newPath.AsSpan()); 86ReadOnlySpan<char> trimmedCurrentPath = Path.TrimEndingDirectorySeparator(FullPath.AsSpan()); 204public DirectoryInfo Root => new DirectoryInfo(Path.GetPathRoot(FullPath)!); 210string destination = Path.GetFullPath(destDirName);

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

39if (Path.EndsInDirectorySeparator(OriginalRootDirectory) && PathInternal.StartsWithDirectorySeparator(relativePath))

src\libraries\System.Private.CoreLib\src\System\IO\Enumeration\FileSystemEntry.Unix.cs (2)

88Path.TryJoin(Directory, FileName, _pathBuffer, out int charsWritten); 182Path.Join(originalRootDirectory, relativePath, fileName);

src\libraries\System.Private.CoreLib\src\System\IO\Enumeration\FileSystemEnumerableFactory.cs (4)

29if (Path.IsPathRooted(expression)) 45ReadOnlySpan<char> directoryName = Path.GetDirectoryName(expression.AsSpan()); 52directory = Path.Join(directory.AsSpan(), directoryName); 77if (Path.DirectorySeparatorChar != '\\' && expression.AsSpan().ContainsAny(@"\""<>"))

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

37string path = isNormalized ? directory : Path.GetFullPath(directory); 38_rootDirectory = Path.TrimEndingDirectorySeparator(path);

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

145_pending.Enqueue((Path.Join(_currentPath, entry.FileName), _remainingRecursionDepth - 1));

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

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

11=> FileSystem.GetUnixFileMode(Path.GetFullPath(path)); 17=> FileSystem.SetUnixFileMode(Path.GetFullPath(path), mode);

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

28FullPath = isNormalized ? fullPath ?? originalPath : Path.GetFullPath(fullPath); 32public override string Name => _name ??= Path.GetFileName(OriginalPath); 46public string? DirectoryName => Path.GetDirectoryName(FullPath); 95string destinationPath = Path.GetFullPath(destFileName); 157string fullDestFileName = Path.GetFullPath(destFileName); 163if (!new DirectoryInfo(Path.GetDirectoryName(FullName)!).Exists) 173_name = Path.GetFileName(fullDestFileName); 188Path.GetFullPath(destinationFileName), 189destinationBackupFileName != null ? Path.GetFullPath(destinationBackupFileName) : null,

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

191=> GetAttributes(handle, handle.Path, Path.GetFileName(handle.Path), continueOnError); 507Interop.Sys.LStat(Path.TrimEndingDirectorySeparator(path), out _fileCache);

src\libraries\System.Private.CoreLib\src\System\IO\FileSystem.cs (4)

33ReadOnlySpan<char> srcNoDirectorySeparator = Path.TrimEndingDirectorySeparator(sourceFullPath.AsSpan()); 34ReadOnlySpan<char> destNoDirectorySeparator = Path.TrimEndingDirectorySeparator(destFullPath.AsSpan()); 41Path.GetFileName(srcNoDirectorySeparator).SequenceEqual(Path.GetFileName(destNoDirectorySeparator)))

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

47fullPath = Path.TrimEndingDirectorySeparator(fullPath);

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

103if (!Directory.Exists(Path.GetDirectoryName(destFullPath))) 248string? directoryName = Path.GetDirectoryName(fullPath); 402ReadOnlySpan<char> srcNoDirectorySeparator = Path.TrimEndingDirectorySeparator(sourceFullPath.AsSpan()); 403ReadOnlySpan<char> destNoDirectorySeparator = Path.TrimEndingDirectorySeparator(destFullPath.AsSpan()); 407if (OperatingSystem.IsBrowser() && Path.EndsInDirectorySeparator(sourceFullPath) && FileExists(sourceFullPath)) 432Path.GetFileName(srcNoDirectorySeparator).SequenceEqual(Path.GetFileName(destNoDirectorySeparator))) // same names. 439&& Path.EndsInDirectorySeparator(sourceFullPath)) 727sb.Length = Path.GetDirectoryNameOffset(sb.AsSpan());

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

57if (PathInternal.IsDirectorySeparator(ch) || ch == Path.VolumeSeparatorChar)

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

102string tempPath = Path.GetTempPath();

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

28return Path.Combine(s_userProductDirectory, featureName, subFeatureName); 41s_userProductDirectory = Path.Combine(

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

42string fullPath = Path.GetFullPath(path);

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

281string normalizedPath = Path.GetFullPath(path); 324requestorPath = Path.GetFullPath(requestorPath); 345string requestedAssemblyPath = Path.Combine(Path.GetDirectoryName(requestorPath)!, requestedAssemblyName.Name + ".dll"); 379string fullPath = Path.GetFullPath(assemblyFile);

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

71string path = Path.Combine(_mediator.ModuleDir, fileName);

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

101_assemblyPaths.TryAdd(Path.GetFileNameWithoutExtension(assemblyPath), assemblyPath); 107_assemblyDirectorySearchPaths = [Path.GetDirectoryName(componentAssemblyPath)!]; 130string assemblyPath = Path.Combine( 163if (unmanagedDllName.Contains(Path.DirectorySeparatorChar)) 175bool isRelativePath = !Path.IsPathFullyQualified(unmanagedDllName); 181string libraryPath = Path.Combine(searchPath, libraryName); 200return pathsList.Split(Path.PathSeparator, StringSplitOptions.RemoveEmptyEntries);

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

762string? parentDirectory = Path.GetDirectoryName(parentAssembly.Location); 766string assemblyPath = Path.Combine(parentDirectory, assemblyName.CultureName!, $"{assemblyName.Name}.dll"); 777assemblyPath = Path.Combine(parentDirectory, assemblyName.CultureName!.ToLowerInvariant(), $"{assemblyName.Name}.dll");

src\libraries\System.Private.CoreLib\src\System\Runtime\Loader\LibraryNameVariation.Unix.cs (1)

36bool containsDelim = libName.Contains(Path.DirectorySeparatorChar);

src\libraries\System.Private.CoreLib\src\System\StartupHookProvider.cs (6)

45startupHookParts.AddRange(diagnosticStartupHooks.Split(Path.PathSeparator)); 50startupHookParts.AddRange(startupHooksVariable.Split(Path.PathSeparator)); 91Path.DirectorySeparatorChar, 92Path.AltDirectorySeparatorChar, 102if (Path.IsPathFullyQualified(startupHookPart)) 147Debug.Assert(Path.IsPathFullyQualified(startupHook.Path));

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

80if (Path.IsPathRooted(id) || IdContainsAnyDisallowedChars(id)) 88string timeZoneFilePath = Path.Combine(timeZoneDirectory, id); 162var fileName = Path.Combine(GetTimeZoneDirectory(), TimeZoneFileName); 251symlinkPath = Path.GetFullPath(symlinkPath, Path.GetDirectoryName(tzFilePath)!); 314string localtimeFilePath = Path.Combine(timeZoneDirectory, "localtime"); 315string posixrulesFilePath = Path.Combine(timeZoneDirectory, "posixrules"); 436TryLoadTzFile(Path.Combine(GetTimeZoneDirectory(), "localtime"), ref rawData, ref id); 453tzFilePath = Path.Combine(GetTimeZoneDirectory(), tzVariable); 513else if (!tzDirectory.EndsWith(Path.DirectorySeparatorChar))

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

500int i = s.LastIndexOf(IO.Path.DirectorySeparatorChar);

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

FileCleanupTestBase.cs (3)

19_testDirectory = Path.Join(Path.GetTempPath(), GetUniqueName()); 46public string GetTestFilePath() => Path.Join(TestDirectory, GetTestFileName());

TempFile.cs (3)

83string file = $"{IO.Path.GetRandomFileName()}_{memberName}_{lineNumber}"; 84return IO.Path.Join(IO.Path.GetTempPath(), file);

System.Private.Xml (7)

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

236path = Path.Combine(Path.GetDirectoryName(type.Assembly.Location)!, $"{assemblyName}.dll"); 241path = Path.Combine(Path.GetDirectoryName(Assembly.GetEntryAssembly()!.Location)!, $"{assemblyName}.dll"); 246path = Path.Combine(Path.GetDirectoryName(AppContext.BaseDirectory)!, $"{assemblyName}.dll");

System\Xml\XmlResolver.cs (1)

48uri = new Uri(Path.GetFullPath(relativeUri!));

System.Reflection.Metadata (3)

System\Reflection\Internal\Utilities\PathUtilities.cs (2)

20(Array.IndexOf(Path.GetInvalidFileNameChars(), '*') >= 0 ? DirectorySeparatorChar : AltDirectorySeparatorChar).ToString(); 48/// <remarks>Unlike <see cref="System.IO.Path.GetFileName(string)"/> this method doesn't check for invalid path characters.</remarks>

System\Reflection\PortableExecutable\PEReader.cs (1)

727peImageDirectory = Path.GetDirectoryName(peImagePath);

System.Reflection.MetadataLoadContext (4)

System\Reflection\PathAssemblyResolver.cs (1)

41string file = Path.GetFileNameWithoutExtension(path);

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

44string? directoryPath = Path.GetDirectoryName(location); 45string modulePath = Path.Combine(directoryPath!, moduleName);

System\Reflection\TypeLoading\Modules\RoModule.cs (1)

53int i = s.LastIndexOf(Path.DirectorySeparatorChar);

System.Runtime (1)

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

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

System.Runtime.Caching (2)

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

102string dir = Path.GetDirectoryName(filePath); 151string dir = Path.GetDirectoryName(filePath);

System.Runtime.Extensions (1)

System.Runtime.Extensions.cs (1)

44[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.IO.Path))]

System.Runtime.InteropServices (3)

System\Runtime\InteropServices\RuntimeEnvironment.cs (3)

22if (!Path.IsPathRooted(runtimeDirectory)) 27char sep = Path.DirectorySeparatorChar; 28return string.Concat(Path.GetDirectoryName(runtimeDirectory), new ReadOnlySpan<char>(in sep));

System.Runtime.Serialization.Schema (1)

System\Runtime\Serialization\Schema\CodeExporter.cs (1)

123string assemblyName = System.IO.Path.GetFileName(assembly.Location);

System.Text.RegularExpressions (1)

System\Text\RegularExpressions\Symbolic\UnicodeCategoryRangesGenerator.cs (1)

27using StreamWriter sw = new StreamWriter($"{Path.Combine(path, classname)}.cs");

System.Windows.Forms (24)

System\Resources\AssemblyNamesTypeResolutionService.cs (1)

16private static readonly string s_dotNetPath = Path.Join(

System\Resources\ResXDataNode.cs (2)

133_fileRefFullPath = !Path.IsPathRooted(fileRefDetails[0]) && basePath is not null 134? Path.Join(basePath, fileRefDetails[0])

System\Resources\ResXFileRef.cs (3)

67if (path1[i] == Path.DirectorySeparatorChar) 87if (path1[i] == Path.DirectorySeparatorChar) 89relPath.Append($"..{Path.DirectorySeparatorChar}");

System\Resources\ResXResourceWriter.cs (2)

311string modifiedBasePath = Path.EndsInDirectorySeparator(BasePath) 313: $"{BasePath}{Path.DirectorySeparatorChar}";

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

1148string path = Path.Join(basePath, CompanyName, ProductName, ProductVersion);

System\Windows\Forms\Controls\DataGridView\DataGridViewHeaderCell.cs (1)

407string themeFilename = Path.GetFileName(VisualStyles.VisualStyleInformation.ThemeFilename);

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

5179_backgroundImageFileName = Path.GetTempFileName();

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

161path = Path.GetFullPath(path);

System\Windows\Forms\Controls\ToolStrips\ProfessionalColorTable.cs (1)

1373string themeFileName = Path.GetFileName(VisualStyleInformation.ThemeFilename);

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

612string mshtmlPath = Path.Join(Environment.GetFolderPath(Environment.SpecialFolder.System), "mshtml.dll");

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

472names.Add(Path.IsPathFullyQualified(fileName) 474: Path.Join(directory, fileName)); 624if (AddExtension && !Path.HasExtension(fileName)) 630var currentExtension = Path.GetExtension(fileName.AsSpan());

System\Windows\Forms\Dialogs\CommonDialogs\FolderBrowserDialog.cs (2)

370string? parent = Path.GetDirectoryName(selectedPath); 377string folder = Path.GetFileName(selectedPath);

System\Windows\Forms\Dialogs\CommonDialogs\OpenFileDialog.cs (2)

180public string SafeFileName => Path.GetFileName(FileName) ?? string.Empty; 197safePaths[i] = Path.GetFileName(fullPaths[i]);

System\Windows\Forms\Dialogs\TaskDialog\TaskDialog.cs (1)

906caption = Path.GetFileName(PInvoke.GetModuleFileNameLongPath(HINSTANCE.Null));

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

301string ext = Path.GetExtension(file is null ? url : file.LocalPath + file.Fragment).ToLower(CultureInfo.InvariantCulture);

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

CurrentReferences.cs (13)

59WinFormsRefPath = Path.Join(RepoRootPath, "artifacts", "obj", "System.Windows.Forms", configuration, tfm, "ref", "System.Windows.Forms.dll"); 62string netCoreAppRefPath = Path.Join(RepoRootPath, ".dotnet", "packs", RefPackageName); 63if (!Directory.Exists(Path.Join(netCoreAppRefPath, netCoreRefsVersion))) 74Path.Join("ref", tfm)) 75.WithNuGetConfigFilePath(Path.Join(RepoRootPath, "NuGet.Config")); 82Path.GetFileName(v).StartsWith(major, StringComparison.InvariantCultureIgnoreCase)); 101string sdkFolderPath = Path.Join(rootFolderPath, ".dotnet", "sdk", version); 116string? testPath = Path.GetDirectoryName(typeof(CurrentReferences).Assembly.Location); 119string? currentFolderPath = Path.GetDirectoryName(testPath); 123string globalJsonPath = Path.Join(currentFolderPath, "global.json"); 131currentFolderPath = Path.GetDirectoryName(currentFolderPath); 140string globalJsonPath = Path.Join(rootFolderPath, "global.json"); 153string configJsonPath = Path.Join(sdkFolderPath, "dotnet.runtimeconfig.json");

TestFileLoader.cs (14)

25builder.Append(Path.DirectorySeparatorChar); 27builder.Append(Path.DirectorySeparatorChar); 56string toolName = Path.GetFileName(Path.GetDirectoryName(filePath))!; 57return await LoadTestFileAsync(Path.Join("Analyzers", toolName), testName, SourceLanguage.None).ConfigureAwait(false); 64string toolName = Path.GetFileName(Path.GetDirectoryName(filePath))!; 65return await LoadTestFileAsync(Path.Join("Generators", toolName), testName, SourceLanguage.None).ConfigureAwait(false); 72string toolName = Path.GetFileName(Path.GetDirectoryName(filePath))!; 73return await LoadTestFileAsync(Path.Join("Analyzers", toolName), testName).ConfigureAwait(false); 80string toolName = Path.GetFileName(Path.GetDirectoryName(filePath))!; 81return await LoadTestFileAsync(Path.Join("Analyzers", toolName), testName, SourceLanguage.VisualBasic).ConfigureAwait(false);

System.Windows.Forms.Design (3)

System\Drawing\BitmapSelector.cs (2)

37=> string.IsNullOrEmpty(Suffix) ? filePath : Path.ChangeExtension(filePath, Suffix + Path.GetExtension(filePath));

System\Windows\Forms\Design\ImageListImageEditor.cs (1)

76image.Name = Path.GetFileName(name);

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

System\Resources\Tools\CodeDomCompileHelper.cs (2)

29MetadataReference.CreateFromFile(Path.Join(Path.GetDirectoryName(corelibPath), "System.Runtime.dll")),

System\Resources\Tools\StronglyTypedResourceBuilderTests.cs (2)

619string expectedUrl = $"{Path.GetTempPath()}testurl1"; 643string changedUrl = $"{Path.GetTempPath()}testurl2";

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

TestHelpers.cs (6)

58string exePath = Path.Join( 91startInfo.WorkingDirectory = Path.GetDirectoryName(path); 185string jsonFile = Path.Join(repoRoot, "global.json"); 208string sdkPath = Path.Join(defaultSdkRoot, dotnetVersion); 244string currentDirectory = Path.GetDirectoryName(codeBasePath); 250string ret = Path.Join(currentDirectory, seek);

System.Windows.Forms.Primitives (6)

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

84string tempFilePath = Path.Join(Path.GetTempPath(), Path.GetRandomFileName());

Windows\Win32\PInvoke.LoadLibrary.cs (3)

17string customPath = Path.Join(startupPath, Libraries.Comctl32); 18Debug.Assert(Path.IsPathFullyQualified(customPath)); 20if (Path.IsPathFullyQualified(customPath))

System.Windows.Forms.Primitives.Tests (1)

Interop\Shell32\ShellItemTests.cs (1)

14string path = Path.GetTempPath();

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

PlatformDetection.Windows.cs (1)

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

System.Windows.Forms.Primitives.TestUtilities.Tests (1)

PathLengthTests.cs (1)

15currentPath = Path.GetFullPath(@"..\..\..\..\..\..\src", currentPath);

System.Windows.Forms.Tests (60)

System\Resources\ResXResourceReaderTests.cs (2)

19string resxPath = Path.GetFullPath(@".\Resources\AxHosts.resx"); 48string resxPath = Path.GetFullPath(@".\Resources\AxHosts.resx");

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")); 139string fileName = Path.Join("bitmaps", "10x16_one_entry_32bit.ico");

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

System\Windows\Forms\InputLanguageTests.cs (4)

225string file = Path.Join(Path.GetTempPath(), $"install-language-{languageTag}.ps1"); 238string file = Path.Join(Path.GetTempPath(), $"uninstall-language-{languageTag}.ps1");

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

10681string projectDirectory = Path.Join(AppDomain.CurrentDomain.BaseDirectory, "..", "..", "..", "..", ".."); 10711string projectDirectory = Path.Join(AppDomain.CurrentDomain.BaseDirectory, "..", "..", "..", "..", ".."); 10712string filePath = Path.Join(projectDirectory, "/src/test/unit/System.Windows.Forms/TestResources/Files/Test");

System\Windows\Forms\ToolStripControlHostTests.cs (6)

402yield return new object[] { Image.FromFile(Path.Join("bitmaps", "nature24bits.gif")) }; 403yield return new object[] { Image.FromFile(Path.Join("bitmaps", "10x16_one_entry_32bit.ico")) }; 1213yield return new object[] { imageTransparentColor, Image.FromFile(Path.Join("bitmaps", "nature24bits.gif")) }; 1214yield return new object[] { imageTransparentColor, Image.FromFile(Path.Join("bitmaps", "10x16_one_entry_32bit.ico")) }; 1339yield return new object[] { Image.FromFile(Path.Join("bitmaps", "nature24bits.gif")), color }; 1340yield return new object[] { Image.FromFile(Path.Join("bitmaps", "10x16_one_entry_32bit.ico")), color };

System\Windows\Forms\ToolStripItemTests.cs (20)

System\Windows\Forms\ToolStripSeparatorTests.cs (6)

116yield return new object[] { Image.FromFile(Path.Join("bitmaps", "nature24bits.gif")) }; 117yield return new object[] { Image.FromFile(Path.Join("bitmaps", "10x16_one_entry_32bit.ico")) }; 423yield return new object[] { imageTransparentColor, Image.FromFile(Path.Join("bitmaps", "nature24bits.gif")) }; 424yield return new object[] { imageTransparentColor, Image.FromFile(Path.Join("bitmaps", "10x16_one_entry_32bit.ico")) }; 533yield return new object[] { Image.FromFile(Path.Join("bitmaps", "nature24bits.gif")), color }; 534yield return new object[] { Image.FromFile(Path.Join("bitmaps", "10x16_one_entry_32bit.ico")), color };

TestResources\ComClasses.cs (1)

15Path.GetFullPath(@"TestResources\VB6\SimpleControl.vb6"),

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

DragDropTests.cs (7)

130string dragDropDirectory = Path.Join(Directory.GetCurrentDirectory(), DragDrop); 140string dragAcceptRtfSourcePath = Path.Join(Directory.GetCurrentDirectory(), Resources, DragAcceptRtf); 147dragAcceptRtfDestPath = Path.Join(dragDropDirectory, DragAcceptRtf); 425string dragAcceptRtfPath = Path.Join(Directory.GetCurrentDirectory(), Resources, DragAcceptRtf); 455string dragAcceptRtfPath = Path.Join(Directory.GetCurrentDirectory(), Resources, DragAcceptRtf); 1084string dragAcceptRtf = Path.Join(Directory.GetCurrentDirectory(), Resources, DragAcceptRtf); 1144string dragAcceptRtf = Path.Join(Directory.GetCurrentDirectory(), Resources, DragAcceptRtf);

Infra\DataCollectionService.cs (9)

230return Path.Join(Path.GetFullPath(logDirectory), $"{timestamp:HH.mm.ss}-{testName}-{errorId}{logId}.{extension}"); 236return Path.Join(GetBaseLogDirectory(), "Screenshots"); 243return Path.GetFullPath(baseLogDirectory); 253string configuration = Path.GetFileName(Path.GetDirectoryName(assemblyDirectory))!; 254return Path.Join(assemblyDirectory[..binPathSeparator], "log", configuration); 257return Path.Join(assemblyDirectory, "xUnitResults"); 263return Path.GetDirectoryName(assemblyPath)!;

Infra\ScreenshotService.cs (1)

33string directory = Path.GetDirectoryName(fullPath)!;

OpenFileDialogTests.cs (3)

28dialog.InitialDirectory = Path.GetTempPath(); 40dialog.InitialDirectory = Path.GetDirectoryName(tempFile.Path); 53dialog.InitialDirectory = Path.GetDirectoryName(tempFile.Path);

System.Xaml (1)

src\Microsoft.DotNet.Wpf\src\Shared\System\Windows\Markup\ReflectionHelper.cs (1)

443Debug.Assert(!assemblyPath.EndsWith(string.Empty + Path.DirectorySeparatorChar, StringComparison.Ordinal), "the assembly path should be a full file path containing file extension");

TaskUsageLogger (2)

TaskUsageLogger.cs (2)

256evaluatedTaskAssemblyPath = Path.GetFullPath(evaluatedTaskAssemblyPath); 405string projectExtension = Path.GetExtension(projectPath);

Templates.Blazor.Tests (67)

BlazorTemplateTest.cs (1)

62var subProjectDirectory = Path.Combine(project.TemplateOutputDir, projectDirectory);

BlazorWasmTemplateTest.cs (9)

29var publishDir = Path.Combine(project.TemplatePublishDir, "wwwroot"); 30Assert.False(File.Exists(Path.Combine(publishDir, "service-worker-assets.js")), "Non-PWA templates should not produce service-worker-assets.js"); 105var publishDir = Path.Combine(project.TemplatePublishDir, "wwwroot"); 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"); 127var fullPath = Path.Combine(basePath, path); 131return File.ReadAllText(Path.Combine(basePath, path)); 166var publishDir = Path.Combine(project.TemplatePublishDir, "wwwroot");

src\ProjectTemplates\Shared\AspNetProcess.cs (1)

61process = Path.ChangeExtension(dllPath, OperatingSystem.IsWindows() ? ".exe" : null);

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

88var subProjectDirectory = Path.Combine(project.TemplateOutputDir, projectDirectory); 107var fullPath = Path.Combine(basePath, path); 111return File.ReadAllText(Path.Combine(basePath, path));

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

18Path.Combine(AppContext.BaseDirectory, "aspnetcore-https.json"), 19Path.Combine(Environment.CurrentDirectory, "aspnetcore-https.json"), 20Path.Combine(AppContext.BaseDirectory, "aspnetcore-https.json"), 30var path = Path.ChangeExtension(json, ".pfx");

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

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

50ProjectGuid = GetRandomLetter() + Path.GetRandomFileName().Replace(".", string.Empty) 56project.TemplateOutputDir = Path.Combine(basePath, project.ProjectName); 68: Path.Combine(Environment.GetEnvironmentVariable("HELIX_DIR"), "Templates", "BaseFolder");

src\ProjectTemplates\Shared\TemplatePackageInstaller.cs (5)

43public static string CustomHivePath { get; } = Path.GetFullPath((string.IsNullOrEmpty(Environment.GetEnvironmentVariable("helix"))) 47: Path.Combine("Hives", ".templateEngine")); 92.Where(p => _templatePackages.Any(t => Path.GetFileName(p).StartsWith(t, StringComparison.OrdinalIgnoreCase))) 131var tempDir = Path.Combine(AppContext.BaseDirectory, Path.GetRandomFileName(), Guid.NewGuid().ToString("D"));

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

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

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

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

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

src\ProjectTemplates\Shared\AspNetProcess.cs (1)

61process = Path.ChangeExtension(dllPath, OperatingSystem.IsWindows() ? ".exe" : null);

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

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

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

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

src\ProjectTemplates\Shared\TemplatePackageInstaller.cs (5)

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

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

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

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

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

183opts.AddUserProfilePreference("download.default_directory", Path.Combine(userProfileDirectory, "Downloads")); 251return Path.Combine(Path.GetTempPath(), "BrowserFixtureUserProfiles", context);

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

235var pidFile = Path.Combine(trackingFolder, $"{process.Id}.{Guid.NewGuid()}.pid");

src\Shared\E2ETesting\WaitAssert.cs (2)

130var screenShotPath = Path.Combine(Path.GetFullPath(E2ETestOptions.Instance.ScreenShotsPath), fileId);

Templates.Blazor.WebAssembly.Tests (71)

BlazorWasmTemplateTest.cs (8)

src\ProjectTemplates\Shared\AspNetProcess.cs (1)

61process = Path.ChangeExtension(dllPath, OperatingSystem.IsWindows() ? ".exe" : null);

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

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

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

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

src\ProjectTemplates\Shared\TemplatePackageInstaller.cs (5)

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

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

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

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

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

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

235var pidFile = Path.Combine(trackingFolder, $"{process.Id}.{Guid.NewGuid()}.pid");

src\Shared\E2ETesting\WaitAssert.cs (2)

130var screenShotPath = Path.Combine(Path.GetFullPath(E2ETestOptions.Instance.ScreenShotsPath), fileId);

Templates.Mvc.Tests (69)

BlazorTemplateTest.cs (4)

176var singleProjectPath = Path.Combine(project.TemplateOutputDir, $"{project.ProjectName}.csproj"); 182var multiProjectPath = Path.Combine(project.TemplateOutputDir, project.ProjectName, $"{project.ProjectName}.csproj"); 186project.TemplateOutputDir = Path.GetDirectoryName(multiProjectPath); 195var appRazorPath = Path.Combine(project.TemplateOutputDir, "Components", "App.razor");

RazorPagesTemplateTest.cs (2)

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

src\ProjectTemplates\Shared\AspNetProcess.cs (1)

61process = Path.ChangeExtension(dllPath, OperatingSystem.IsWindows() ? ".exe" : null);

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

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

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

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

src\ProjectTemplates\Shared\TemplatePackageInstaller.cs (5)

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

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

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

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

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

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

235var pidFile = Path.Combine(trackingFolder, $"{process.Id}.{Guid.NewGuid()}.pid");

src\Shared\E2ETesting\WaitAssert.cs (2)

130var screenShotPath = Path.Combine(Path.GetFullPath(E2ETestOptions.Instance.ScreenShotsPath), fileId);

Templates.Tests (71)

BaselineTest.cs (1)

123var fullPath = Path.Combine(basePath, path);

ByteOrderMarkTest.cs (5)

48var filePath = Path.GetFullPath(file); 86var filePath = Path.GetFullPath(file); 107var AssetsDir = Path.Combine(currentDirectory, "Assets"); 108var path = Path.Combine(projectName, "content"); 109var templateDirectoryPath = Path.Combine(AssetsDir, path);

IdentityUIPackageTest.cs (2)

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

src\ProjectTemplates\Shared\AspNetProcess.cs (1)

61process = Path.ChangeExtension(dllPath, OperatingSystem.IsWindows() ? ".exe" : null);

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

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

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

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

src\ProjectTemplates\Shared\TemplatePackageInstaller.cs (5)

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

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

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

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

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

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

235var pidFile = Path.Combine(trackingFolder, $"{process.Id}.{Guid.NewGuid()}.pid");

src\Shared\E2ETesting\WaitAssert.cs (2)

130var screenShotPath = Path.Combine(Path.GetFullPath(E2ETestOptions.Instance.ScreenShotsPath), fileId);

Test.Utilities (25)

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

src\Compilers\Core\Portable\FileSystem\PathUtilities.cs (4)

src\Compilers\Core\Portable\InternalUtilities\FileNameUtilities.cs (3)

src\Compilers\Core\Portable\InternalUtilities\PlatformInformation.cs (2)

23public static bool IsWindows => Path.DirectorySeparatorChar == '\\'; 25public static bool IsUnix => Path.DirectorySeparatorChar == '/';

src\Dependencies\Contracts\Contract.cs (1)

160var fileName = filePath is null ? null : Path.GetFileName(filePath);

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

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

15private static readonly char[] DirectorySeparatorCharacters = [Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar];

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EditorConfig\LanguageExtensions.cs (1)

16var fileExtension = Path.GetExtension(filePath);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EditorConfig\Parsing\Sections\Section.cs (1)

39var containingDirectory = Path.GetDirectoryName(FilePath);

TestDiscoveryWorker (3)

Program.cs (3)

46outputFilePath = Path.Combine(Path.GetDirectoryName(assemblyFilePath)!, "testlist.json"); 63string assemblyFileName = Path.GetFileName(assemblyFilePath);

TestPassApp (2)

CommonControl2.cs (2)

15string executablePath = Path.GetDirectoryName(executable); 16string page = Path.Join(executablePath, "HTMLPage1.html");

TestProject.AppHost (1)

TestProgram.cs (1)

62var serviceAPath = Path.Combine(Projects.TestProject_AppHost.ProjectPath, @"..\TestProject.ServiceA\TestProject.ServiceA.csproj");

TestTasks (3)

InjectRequestHandler.cs (3)

59var outputFolder = Path.GetDirectoryName(depsFile); 61File.Copy(Path.Combine(outputFolder, bitnessString, aspnetcoreV2Name), Path.Combine(outputFolder, aspnetcoreV2Name), overwrite: true);

Text.Analyzers (27)

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

src\Compilers\Core\Portable\FileSystem\PathUtilities.cs (4)

src\Compilers\Core\Portable\InternalUtilities\FileNameUtilities.cs (3)

src\Compilers\Core\Portable\InternalUtilities\PlatformInformation.cs (2)

23public static bool IsWindows => Path.DirectorySeparatorChar == '\\'; 25public static bool IsUnix => Path.DirectorySeparatorChar == '/';

src\Dependencies\Contracts\Contract.cs (1)

160var fileName = filePath is null ? null : Path.GetFileName(filePath);

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

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

15private static readonly char[] DirectorySeparatorCharacters = [Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar];

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EditorConfig\LanguageExtensions.cs (1)

16var fileExtension = Path.GetExtension(filePath);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EditorConfig\Parsing\Sections\Section.cs (1)

39var containingDirectory = Path.GetDirectoryName(FilePath);

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

61var thisAssemblyFolder = Path.GetDirectoryName(thisAssemblyName); 63? Path.Combine(thisAssemblyFolder, assemblySimpleName + ".dll")

UIAutomationClient (1)

MS\Internal\Automation\ProxyManager.cs (1)

317return System.IO.Path.GetFileName(sb.ToString().ToLower(CultureInfo.InvariantCulture));

vbc (13)

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

49internal static bool IsRunningOnWindows => Path.DirectorySeparatorChar == '\\'; 114var tempDir = Path.GetTempPath();

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

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

128loggingFilePath = Path.Combine(loggingFilePath, $"server.{processId}.log");

src\Compilers\Shared\NamedPipeUtil.cs (1)

36return Path.Combine("/tmp", pipeName);

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

63var filePath = Path.Combine(item, fileName);

src\Compilers\Shared\Vbc.cs (1)

26var responseFile = Path.Combine(buildPaths.ClientDirectory, VisualBasicCompiler.ResponseFileName);

VBCSCompiler (17)

src\Compilers\Server\VBCSCompiler\CompilerRequestHandler.cs (2)

75AnalyzerAssemblyLoader = Microsoft.CodeAnalysis.AnalyzerAssemblyLoader.CreateNonLockingLoader(Path.Combine(Path.GetTempPath(), "VBCSCompiler", "AnalyzerAssemblyLoader"));

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

20: this(metadataProvider, Path.Combine(buildPaths.ClientDirectory, ResponseFileName), args, buildPaths, libDirectory, analyzerLoader, driverCache)

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

79var allModules = GetAllModules(primaryModule, Path.GetDirectoryName(fullPath)!);

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

22: this(metadataProvider, Path.Combine(buildPaths.ClientDirectory, ResponseFileName), args, buildPaths, libDirectory, analyzerLoader, driverCache)

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

49internal static bool IsRunningOnWindows => Path.DirectorySeparatorChar == '\\'; 114var tempDir = Path.GetTempPath();

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

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

128loggingFilePath = Path.Combine(loggingFilePath, $"server.{processId}.log");

src\Compilers\Shared\NamedPipeUtil.cs (1)

36return Path.Combine("/tmp", pipeName);

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

63var filePath = Path.Combine(item, fileName);

VBCSCompiler.UnitTests (40)

AnalyzerConsistencyCheckerTests.cs (1)

105var result = AnalyzerConsistencyChecker.Check(Path.GetDirectoryName(TestFixture.Alpha)!, analyzerReferences, assemblyLoader, Logger);

BuildClientTests.cs (7)

332var path = string.Format(@"q:{0}the{0}path", Path.DirectorySeparatorChar); 335Assert.Equal(name, BuildServerConnection.GetPipeName(path + Path.DirectorySeparatorChar)); 336Assert.Equal(name, BuildServerConnection.GetPipeName(path + Path.DirectorySeparatorChar + Path.DirectorySeparatorChar)); 342var path = string.Format(@"q:{0}the{0}path", Path.DirectorySeparatorChar); 351var path1 = string.Format(@"q:{0}the{0}path", Path.DirectorySeparatorChar); 352var path2 = string.Format(@"Q:{0}The{0}Path", Path.DirectorySeparatorChar);

CompilerServerApiTest.cs (1)

146var vbcsFilePath = Path.Combine(toolDir, "VBCSCompiler.dll");

CompilerServerTests.cs (20)

ServerUtil.cs (3)

45tempDirectory ?? Path.GetTempPath(), 52tempDirectory ?? Path.GetTempPath(), 159internal static string DefaultClientDirectory { get; } = Path.GetDirectoryName(typeof(BuildClientTests).Assembly.Location);

TouchedFileLoggingTests.cs (6)

60var touchedBase = Path.Combine(touchedDir.Path, "touched"); 69new BuildPaths(clientDirectory, _baseDirectory, RuntimeEnvironment.GetRuntimeDirectory(), Path.GetTempPath()), 77Path.ChangeExtension(source1, "exe"), 111var touchedBase = Path.Combine(touchedDir.Path, "touched"); 120new BuildPaths(clientDirectory, _baseDirectory, RuntimeEnvironment.GetRuntimeDirectory(), Path.GetTempPath()), 128Path.ChangeExtension(source1, "exe"),

VBCSCompilerServerTests.cs (2)

40var baseDirectory = Path.Combine(Path.GetTempPath(), TestBase.GetUniqueName());

vbi (3)

Vbi.vb (3)

18Dim vbiDirectory = Path.GetDirectoryName(GetType(Vbi).GetTypeInfo().Assembly.ManifestModule.FullyQualifiedName) 24tempDir:=Path.GetTempPath()) 27responseFile:=Path.Combine(vbiDirectory, InteractiveResponseFileName),

VisualBasicSyntaxGenerator (6)

Program.vb (6)

74Dim prefix = Path.GetFileName(inputFile) 75Dim mainFile = Path.Combine(outputPath, $"VisualBasic.Grammar.g4") 155Dim prefix = Path.GetFileName(inputFile) 156Dim mainFile = Path.Combine(outputPath, $"{prefix}.Main.Generated.vb") 157Dim syntaxFile = Path.Combine(outputPath, $"{prefix}.Syntax.Generated.vb") 158Dim internalFile = Path.Combine(outputPath, $"{prefix}.Internal.Generated.vb")

Wasm.Performance.ConsoleHost (3)

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

WindowsBase.Tests (2)

Helpers.cs (2)

14public static string GetResourcePath(string name) => Path.GetFullPath(Path.Combine("Resources", name));

WinFormsControlsTest (11)

DragDrop.cs (9)

134e.Message = $"{Path.GetFileNameWithoutExtension(files[0])}%1"; 135e.MessageReplacementToken = Path.GetExtension(files[0]); 260e.Message = $"{Path.GetFileNameWithoutExtension(files[0])}%1"; 261e.MessageReplacementToken = Path.GetExtension(files[0]); 302e.Message = $"{Path.GetFileNameWithoutExtension(files[0])}%1"; 303e.MessageReplacementToken = Path.GetExtension(files[0]); 385string dragDropDataDirectory = Path.Join( 403string nyanCatAsciiPath = Path.Join( 540Path.Join(Directory.GetCurrentDirectory(),

ListViewTest.cs (1)

254Text = Path.GetFileName(file),

MediaPlayer.cs (1)

12axWindowsMediaPlayer1.URL = Path.GetFullPath(@".\resources\media.mpg");

xunit.console (39)

CommandLine.cs (2)

83return Path.GetFullPath(fileName); 511var directory = Path.GetDirectoryName(path);

common\AssemblyResolution\AssemblyHelper.cs (1)

54var assemblyFolder = Path.GetDirectoryName(assemblyFileName);

common\AssemblyResolution\DependencyContextAssemblyCache.cs (8)

72.Select(path => Tuple.Create(Path.GetFileNameWithoutExtension(path), Tuple.Create(tuple.Item1, tuple.Item2)))) 86.Select(path => Tuple.Create(Path.GetFileName(path), Tuple.Create(tuple.Item1, tuple.Item2)))) 211var assemblyPath = Path.Combine(Path.GetFullPath(assemblyFolder), assemblyName); 238var resolvedAssemblyPath = assemblies.FirstOrDefault(a => string.Equals(assemblyName, Path.GetFileNameWithoutExtension(a), StringComparison.OrdinalIgnoreCase)); 241resolvedAssemblyPath = Path.GetFullPath(resolvedAssemblyPath); 281var resolvedAssemblyPath = assemblies.FirstOrDefault(a => string.Equals(formattedUnmanagedDllName, Path.GetFileName(a), StringComparison.OrdinalIgnoreCase)); 283return Path.GetFullPath(resolvedAssemblyPath);

common\AssemblyResolution\Microsoft.DotNet.PlatformAbstractions\ApplicationEnvironment.cs (1)

16return Path.GetFullPath(basePath);

common\AssemblyResolution\Microsoft.Extensions.DependencyModel\DependencyContextJsonReader.cs (2)

402groupRuntimeAssemblies.Where(a => Path.GetFileName(a) != "_._"))); 414groupNativeLibraries.Where(a => Path.GetFileName(a) != "_._")));

common\AssemblyResolution\Microsoft.Extensions.DependencyModel\DependencyContextLoader.cs (1)

116var depsJsonFile = Path.ChangeExtension(assembly.Location, DepsJsonExtension);

common\AssemblyResolution\Microsoft.Extensions.DependencyModel\Resolution\AppBaseCompilationAssemblyResolver.cs (4)

50var refsPath = Path.Combine(_basePath, RefsDirectoryName); 73var sharedDirectory = Path.GetDirectoryName(sharedPath); 74var sharedRefs = Path.Combine(sharedDirectory, RefsDirectoryName); 87var assemblyFile = Path.GetFileName(assembly);

common\AssemblyResolution\Microsoft.Extensions.DependencyModel\Resolution\PackageCompilationAssemblyResolver.cs (2)

49return listOfDirectories.Split(new char [] { Path.PathSeparator }, StringSplitOptions.RemoveEmptyEntries ); 74return new string[] { Path.Combine(basePath, ".nuget", "packages") };

common\AssemblyResolution\Microsoft.Extensions.DependencyModel\Resolution\ReferenceAssemblyPathResolver.cs (5)

65var relativeToReferenceAssemblies = Path.Combine(_defaultReferenceAssembliesPath, path); 73var name = Path.GetFileName(path); 76var fallbackFile = Path.Combine(fallbackPath, name); 94var net20Dir = Path.Combine(environment.GetEnvironmentVariable("WINDIR"), "Microsoft.NET", "Framework", "v2.0.50727"); 135return Path.Combine(

common\AssemblyResolution\Microsoft.Extensions.DependencyModel\Resolution\ResolverUtils.cs (4)

15path = Path.Combine(library.Name.ToLowerInvariant(), library.Version.ToLowerInvariant()); 18packagePath = Path.Combine(basePath, path); 29fullName = Path.GetFullPath(Path.Combine(basePath, assemblyPath));

common\AssemblyResolution\XunitPackageCompilationAssemblyResolver.cs (2)

36results = probeDirectories.Split(new char[] { Path.PathSeparator }, StringSplitOptions.RemoveEmptyEntries).ToList(); 54results.Add(Path.Combine(basePath, ".nuget", "packages"));

ConsoleRunner.cs (7)

61if (!defaultDirectory.EndsWith(new string(new[] { Path.DirectorySeparatorChar }), StringComparison.Ordinal)) 62defaultDirectory += Path.DirectorySeparatorChar; 131var runnerPath = Path.GetDirectoryName(typeof(Program).GetTypeInfo().Assembly.Location); 138foreach (var dllFile in Directory.GetFiles(runnerPath, "*.dll").Select(f => Path.Combine(runnerPath, f))) 144var assembly = Assembly.Load(new AssemblyName(Path.GetFileNameWithoutExtension(dllFile))); 359var assemblyDisplayName = Path.GetFileNameWithoutExtension(assembly.AssemblyFilename); 384completionMessages.TryAdd(Path.GetFileName(assembly.AssemblyFilename), new ExecutionSummary());